Struct Tension 

pub struct Tension {
    pub id: TensionId,
    pub left: TensionSide,
    pub right: TensionSide,
    pub conflict_type: ConflictType,
    pub detected_at: Timestamp,
    pub resolution: Option<TensionResolution>,
}

Tension - explicit conflict between two proposals.

Per CONTEXT.md: Tension { left: ProposedFact, right: ProposedFact, conflict_type } We use references (IDs) rather than owned proposals for flexibility.

Example

use converge_core::types::{Tension, TensionId, TensionSide, ConflictType, ProposalId, Timestamp};

let tension = Tension::new(
    TensionId::new("tension-1"),
    TensionSide::new(ProposalId::new("p1"), "Focus on enterprise sales"),
    TensionSide::new(ProposalId::new("p2"), "Focus on SMB market"),
    ConflictType::PriorityMismatch,
);

assert_eq!(tension.id.as_str(), "tension-1");
assert!(!tension.is_resolved());

Fields

id: TensionId

Unique identifier for this tension.

left: TensionSide

Left side of the conflict.

right: TensionSide

Right side of the conflict.

conflict_type: ConflictType

Type of conflict.

detected_at: Timestamp

When the tension was detected.

resolution: Option<TensionResolution>

Resolution (if resolved).

Implementations

impl Tension

pub fn new( id: TensionId, left: TensionSide, right: TensionSide, conflict_type: ConflictType, ) -> Tension

Create a new unresolved tension.

pub fn is_resolved(&self) -> bool

Check if the tension has been resolved.

pub fn resolve(&mut self, resolution: TensionResolution)

Resolve the tension.

pub fn winner(&self) -> Option<&ProposalId>

Get the winning proposal ID (if resolved with a winner).

Trait Implementations

impl Clone for Tension

fn clone(&self) -> Tension

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tension

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tension

fn deserialize<__D>( __deserializer: __D, ) -> Result<Tension, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Tension

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

where __S: Serializer,

Serialize this value into the given Serde serializer.