Enum ReasoningMode 

pub enum ReasoningMode {
    Offline,
    Ci,
    Fast,
    Standard,
    Strict,
}

How much independent review a session may use, and where from. The policy reads it for the review budget; availability reads it to leave advisors out (ci all of them, offline every one that leaves the machine). standard is the default.

use majordomus_cli::reasoning::availability::ReasoningMode;

assert_eq!(ReasoningMode::default(), ReasoningMode::Standard);
assert_eq!(serde_json::to_value(ReasoningMode::Offline).unwrap(), "offline");
let m: ReasoningMode = serde_json::from_str("\"strict\"").unwrap();
assert_eq!(m, ReasoningMode::Strict);

Variants

Offline

No network: only advisors that stay on this machine.

Ci

Deterministic: no advisor at all, whatever is installed.

Fast

Review only where the blast radius is high.

Standard

Review where uncertainty is material.

Strict

Review wider, and complementary review where the stakes are highest.

Implementations

impl ReasoningMode

pub fn parse(word: &str) -> Option<Self>

The mode a word names, ignoring surrounding whitespace. None for a word that names no mode: a caller skips it rather than guessing at one.

use majordomus_cli::reasoning::availability::ReasoningMode;

assert_eq!(ReasoningMode::parse(" ci "), Some(ReasoningMode::Ci));
assert_eq!(ReasoningMode::parse("loud"), None);

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

The word that names the mode, as configuration, profiles and plans write it: the inverse of ReasoningMode::parse.

use majordomus_cli::reasoning::availability::ReasoningMode;

for word in ["offline", "ci", "fast", "standard", "strict"] {
    assert_eq!(ReasoningMode::parse(word).unwrap().as_str(), word);
}

Trait Implementations

impl Clone for ReasoningMode

fn clone(&self) -> ReasoningMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReasoningMode

impl Debug for ReasoningMode

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

Formats the value using the given formatter.

impl Default for ReasoningMode

fn default() -> ReasoningMode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReasoningMode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReasoningMode

impl JsonSchema for ReasoningMode

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 Ord for ReasoningMode

fn cmp(&self, other: &ReasoningMode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ReasoningMode

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

fn partial_cmp(&self, other: &ReasoningMode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ReasoningMode

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 ReasoningMode