Struct Joint 

pub struct Joint<Q> { /* private fields */ }

A quorum rule that accepts an ID set only when every one of its rules accepts it.

A membership change can move through a joint of the old and the new rule, whose every quorum is a quorum of both. An empty Joint accepts no set, like an empty Vec<BTreeSet<ID>>.

ids() returns the union of the IDs of every rule, each ID once.

Examples

use std::collections::BTreeSet;
use std::num::NonZeroU64;

use quorum_set::{Joint, QuorumSet, ThresholdQuorumSet};

let two = NonZeroU64::new(2).unwrap();
let old = ThresholdQuorumSet::new(two, BTreeSet::from([1, 2, 3]));
let new = ThresholdQuorumSet::new(two, BTreeSet::from([2, 3, 4]));
let joint = Joint::new([old, new]);

// {1,2} holds 2 of the old IDs but only 1 of the new IDs.
let accepts_one_two = joint.is_quorum([1, 2].iter());
assert!(!accepts_one_two);
let accepts_one_two_four = joint.is_quorum([1, 2, 4].iter());
assert!(accepts_one_two_four);

Implementations

impl<Q> Joint<Q>

pub fn new(rules: impl IntoIterator<Item = Q>) -> Self

Builds a rule that accepts an ID set only when every one of rules accepts it.

pub fn rules(&self) -> &[Q]

Returns the rules, in the order they were given.

Trait Implementations

impl<Q: Clone> Clone for Joint<Q>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q: Debug> Debug for Joint<Q>

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

Formats the value using the given formatter.

impl<Q> Default for Joint<Q>

Written by hand: derive(Default) would require Q: Default.

fn default() -> Self

Returns the “default value” for a type.

impl<Q: Eq> Eq for Joint<Q>

impl<Q: PartialEq> PartialEq for Joint<Q>

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

Equality operator ==.

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

Inequality operator !=.

impl<Q> QuorumBridge<Joint<Q>> for Joint<Q>

where Q: QuorumSet + Clone, Q::Id: Ord,

Builds the joint of the source and target rules.

fn joint_with(&self, other: Joint<Q>) -> Self

Return the rules of self followed by the rules of other. Return an empty joint when self or other is empty: an empty joint has no quorum, so a joint with it has no quorum either.

impl<Q> QuorumIntersection<Joint<Q>> for Joint<Q>

where Q: QuorumIntersection<Q>, Q::Id: Ord,

Two joints are treated as having quorum intersection when some rule of one intersects some rule of the other: every quorum of a joint is also a quorum of each of its rules, so every quorum of one joint then intersects every quorum of the other. This is sufficient but not necessary for that property, so this check answers None for some pairs of joints whose quorums do in fact all intersect.

fn intersects_with(&self, other: &Joint<Q>) -> Option<bool>

Return the answer of the rule check when each joint holds one rule. For other joints, return Some(true) when some rule of self intersects some rule of other.

When either joint is empty, return Some(true): an empty joint has no quorum, so no pair of quorums can be disjoint.

Return None for every other pair: two rules that do not intersect prove nothing about two joints that contain them.

impl<Q> QuorumSet for Joint<Q>

where Q: QuorumSet, Q::Id: Ord,

type Id = <Q as QuorumSet>::Id

Node ID type in this quorum set.

type Iter = IntoIter<<Q as QuorumSet>::Id>

Iterator over every voter ID tracked by this quorum set.

fn is_quorum<'a, I>(&self, ids: I) -> bool

where Self::Id: 'a, I: Iterator<Item = &'a Self::Id> + Clone,

Return true if the candidate IDs satisfy this quorum rule.

fn ids(&self) -> Self::Iter

Return all voter IDs in this quorum set.

impl<Q: PartialEq> StructuralPartialEq for Joint<Q>