Enum Standing 

pub enum Standing {
    Selected,
    Excluded,
    Deduplicated,
    NotReached,
    Unknown,
}

What one identifier’s standing in a compiled context is. Where one identifier stands with respect to a compiled context.

The pair to be careful about is NotReached and Unknown, because they look alike in a rendering and mean opposite things. NotReached says the index holds the object and this request did not reach it — the request is what to change, and raising the depth or the budget may well bring it in. Unknown says the index holds nothing under that identifier: the request is fine and the identifier is wrong, or the object is not in this repository. Collapsing the two would send a reader to tune a request that was never the problem.

Deduplicated is the third one worth naming: the thing is in the answer, under another identifier, which is neither in nor out.

use majordomus_cli::devcontext::Standing;

// in the answer, one way or another
let present = [Standing::Selected, Standing::Deduplicated];
// reached and not given, so the request is what to change
let request_bound = [Standing::Excluded, Standing::NotReached];
for s in present {
    assert!(!request_bound.contains(&s));
}

// the two that must not be confused: one is the request's fault, one is not
assert_eq!(Standing::NotReached.as_str(), "not_reached");
assert_ne!(Standing::NotReached, Standing::Unknown);
assert_eq!(
    serde_json::to_value(Standing::NotReached).unwrap(),
    serde_json::json!(Standing::NotReached.as_str()),
);

Variants

Selected

In the answer.

Excluded

Reached and not given; the exclusion says why.

Deduplicated

Folded into another identifier, or dropped for one.

NotReached

The index holds it and this request never reached it.

Unknown

The index holds nothing under that identifier.

Implementations

impl Standing

pub fn as_str(self) -> &'static str

The word this standing is reported under.

use majordomus_cli::devcontext::Standing;
assert_eq!(Standing::NotReached.as_str(), "not_reached");

Trait Implementations

impl Clone for Standing

fn clone(&self) -> Standing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Standing

impl Debug for Standing

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Standing

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Standing

impl JsonSchema for Standing

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 Standing

fn eq(&self, other: &Standing) -> 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 Standing

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 Standing