Struct RecoveryOptions 

pub struct RecoveryOptions {

    pub max_retries: u32,
    pub maximum_retry_exposure_seconds: f64,
    pub reconnect_delay_seconds: f64,
    pub command_timeout_seconds: f64,
    pub download_timeout_seconds: f64,
    pub exposure_grace_seconds: f64,
    pub cooling_timeout_seconds: f64,
    pub temperature_tolerance_c: f64,
    pub cooling_stable_samples: u32,
    pub cooling_sample_seconds: f64,
    pub ready_frame_download_retries: u32,
    pub direct_read_retries: u32,
    pub direct_read_chunk_kib: u32,
    pub usb_reset_after_failures: u32,
    pub usb_port_cycle: bool,
}

Fields

max_retries: u32

maximum_retry_exposure_seconds: f64

reconnect_delay_seconds: f64

command_timeout_seconds: f64

download_timeout_seconds: f64

exposure_grace_seconds: f64

cooling_timeout_seconds: f64

temperature_tolerance_c: f64

cooling_stable_samples: u32

cooling_sample_seconds: f64

ready_frame_download_retries: u32

direct_read_retries: u32

direct_read_chunk_kib: u32

usb_reset_after_failures: u32

usb_port_cycle: bool

Implementations

impl RecoveryOptions

pub fn fields() -> Vec<RecoveryField>

Examples found in repository

examples/export_recovery.rs (line 9)

fn managed_options() -> String {
    let mut text = String::from(
        "// Generated by regain-core export_recovery; edit recovery.rs instead.\nnamespace Regain.Core;\n\npublic sealed record RecoveryOptions\n{\n",
    );
    let fields = RecoveryOptions::fields();
    for field in &fields {
        let name = format!("{}{}", field.key[..1].to_uppercase(), &field.key[1..]);
        let ty = match field.value_type {
            RecoveryType::Integer(_, _) | RecoveryType::PowerOfTwo(_, _) => "int",
            RecoveryType::Number { .. } => "double",
            RecoveryType::Boolean => "bool",
        };
        writeln!(
            text,
            "    public {ty} {name} {{ get; init; }} = {};",
            field.default
        )
        .unwrap();
    }
    text.push_str("    public void Validate()\n    {\n");
    for field in fields {
        let name = format!("{}{}", field.key[..1].to_uppercase(), &field.key[1..]);
        let condition = match field.value_type {
            RecoveryType::Integer(min, max) => format!("{name} < {min} || {name} > {max}"),
            RecoveryType::PowerOfTwo(min, max) => {
                format!("{name} < {min} || {name} > {max} || ({name} & ({name} - 1)) != 0")
            }
            RecoveryType::Number {
                minimum,
                exclusive,
                maximum,
            } => format!(
                "double.IsNaN({name}) || double.IsInfinity({name}) || {name} {} {minimum} || {name} > {maximum}",
                if exclusive { "<=" } else { "<" }
            ),
            RecoveryType::Boolean => continue,
        };
        writeln!(text, "        if ({condition})\n            throw new System.ArgumentOutOfRangeException(nameof({name}));").unwrap();
    }
    text.push_str("    }\n}\n");
    text
}

pub fn validate(&self) -> Result<()>

pub fn schema() -> Value

Strict hub/frontend schema without a schema/compiler dependency. Legacy profile loading intentionally still tolerates unknown keys.

Examples found in repository

examples/export_recovery.rs (line 75)

fn main() -> Result<(), Box<dyn Error>> {
    let mut args = std::env::args().skip(1);
    let contract = args
        .next()
        .ok_or("Usage: export_recovery CONTRACT MANAGED [--check]")?;
    let managed = args
        .next()
        .ok_or("Usage: export_recovery CONTRACT MANAGED [--check]")?;
    let option = args.next();
    if option.as_deref().is_some_and(|s| s != "--check") || args.next().is_some() {
        return Err("Unknown option".into());
    }
    let description = serde_json::json!({"contractVersion":1,"schema":RecoveryOptions::schema()});
    save(
        Path::new(&contract),
        &(serde_json::to_string_pretty(&description)? + "\n"),
        option.is_some(),
    )?;
    save(Path::new(&managed), &managed_options(), option.is_some())
}

impl RecoveryOptions

pub fn replacement_exposures(&self, microseconds: u64) -> u32

Same microsecond exposure and inclusive threshold used by core capture and every native outer supervisor. Rereads have separate eligibility.

Trait Implementations

impl Clone for RecoveryOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecoveryOptions

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

Formats the value using the given formatter.

impl Default for RecoveryOptions

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RecoveryOptions

where RecoveryOptions: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RecoveryOptions

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RecoveryOptions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RecoveryOptions