Struct DisagreementPosition 

pub struct DisagreementPosition {
    pub source: String,
    pub position: String,
}

One side of a disagreement: whose position it is, and the position in one line.

The source is primary for the executor, or the id of a completed consultation; the store refuses a position sourced from a consultation that did not complete.

use majordomus_cli::reasoning::record::DisagreementPosition;

let p = DisagreementPosition { source: "primary".into(), position: "keep the lock".into() };
let json = serde_json::to_value(&p).unwrap();
assert_eq!(json, serde_json::json!({ "source": "primary", "position": "keep the lock" }));

Fields

source: String

Whose position: primary, or a completed consultation’s record id.

position: String

The position, in one line.

Trait Implementations

impl Clone for DisagreementPosition

fn clone(&self) -> DisagreementPosition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DisagreementPosition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DisagreementPosition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DisagreementPosition

impl JsonSchema for DisagreementPosition

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 DisagreementPosition

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

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 DisagreementPosition