Struct EdgeRule 

pub struct EdgeRule {
    pub edge: String,
    pub means: String,
    pub forward: Option<f64>,
    pub reverse: Option<f64>,
    pub reason: String,
    pub refused: bool,
}

One edge of the composed graph, and what the compiler does with it.

Every edge kind the graph declares gets a row, followed or not, which is the property that makes this projection worth reading: an edge added to the graph and not to the traversal table appears here as refused with a reason saying the compiler has no rule for it, rather than being silently unfollowed. A table that only listed the edges it followed could not tell you what it was ignoring.

forward and reverse are absent rather than zero when the edge is not followed that way, so “not followed” is one representation and not two. means is the graph’s own account of the relation; reason is this compiler’s account of why it is or is not context, in both directions.

use majordomus_cli::devcontext::{edge_policy, policy, EdgeRule};
use majordomus_cli::synthetic::SyntheticRepository;

let repo = SyntheticRepository::small().unwrap();
let ctx = repo.context().unwrap();
let rules = policy(&ctx).unwrap();

// one row per edge kind the graph declares, followed or refused
let edges: &[EdgeRule] = &rules.edges;
assert!(!edges.is_empty(), "the graph declares edges");
for e in edges {
    // the row always says what the relation is and what was decided about it
    assert!(!e.means.is_empty() && !e.reason.is_empty(), "{}", e.edge);

    if e.refused {
        // not followed in either direction, and absent rather than zero
        assert!(e.forward.is_none() && e.reverse.is_none(), "{}", e.edge);
        assert!(edge_policy(&e.edge).is_none(), "{} is refused and in the table", e.edge);
    } else {
        // followed at least one way, at a weight the table declares
        assert!(e.forward.is_some() || e.reverse.is_some(), "{}", e.edge);
        let p = edge_policy(&e.edge).expect("a followed edge has a policy");
        assert_eq!(e.forward, (p.forward > 0.0).then_some(p.forward));
        assert_eq!(e.reverse, (p.reverse > 0.0).then_some(p.reverse));
    }
}

Fields

edge: String

The edge kind, as the composed graph names it.

means: String

What the graph asserts by it.

forward: Option<f64>

The relevance multiplier when followed source to target; absent when refused.

reverse: Option<f64>

The multiplier when followed target to source; absent when refused.

reason: String

Why the target is context for the source, or why the edge is refused.

refused: bool

True when the compiler will not follow it in either direction.

Trait Implementations

impl Clone for EdgeRule

fn clone(&self) -> EdgeRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeRule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EdgeRule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for EdgeRule

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EdgeRule

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EdgeRule

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 EdgeRule