Struct Hop 

pub struct Hop {
    pub to: String,
    pub warnings: Vec<String>,
    pub failure: Option<String>,
    pub leg: HopDelta,
    pub path_dependent: Option<String>,
    pub path_dependent_electrical: bool,
    pub emptied: Vec<String>,
    pub resurrected: Vec<String>,
    pub revisit_of: Option<usize>,
    pub drift: Option<String>,
    pub drift_electrical: bool,
}

One step of a walk: write the running network in a format, read it back, and say what moved.

Fields

to: String

The format written at this step.

warnings: Vec<String>

failure: Option<String>

leg: HopDelta

Against the network this hop started from: the leg’s own loss, the same quantity super::compare measures, but from a walked input rather than the pristine case.

path_dependent: Option<String>

Set when converting the origin straight to this format gives a different network than arriving here along the walk. The chain’s route changed the destination, which no single leg can state.

path_dependent_electrical: bool

Whether that difference reaches an electrical property (counts, power, Y_bus, DC terminals) rather than retained extras alone. Retention honestly thins along a chain, so only the electrical kind is graded a defect.

emptied: Vec<String>

Counts the origin had that are zero here. Not a defect on its own: it says a later clean hop may be clean only because the table is empty.

resurrected: Vec<String>

Counts that were zero at the previous hop and are nonzero here.

revisit_of: Option<usize>

The earlier hop this format was last written at, when the walk revisits one.

drift: Option<String>

Set when that revisit produced a different network than the first visit: conversion has not settled.

drift_electrical: bool

As path_dependent_electrical, for the drift.

Trait Implementations

impl Clone for Hop

fn clone(&self) -> Hop

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hop

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hop

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Hop

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

where __S: Serializer,

Serialize this value into the given Serde serializer.