kasuari 0.4.12

A rust layout solver for GUIs, based on the Cassowary algorithm. A fork of the unmaintained cassowary-rs crate with improvments and bug fixes. Kasuari is the indonesian name for the cassowary bird.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#[cfg(not(feature = "portable-atomic"))]
use alloc::sync::Arc;
use core::hash::{Hash, Hasher};
use core::ops;

#[cfg(feature = "portable-atomic")]
use portable_atomic_util::Arc;

use crate::{Expression, RelationalOperator, Strength, Term, Variable, WeightedRelation};

#[derive(Debug)]
struct Inner {
    expression: Expression,
    strength: Strength,
    operator: RelationalOperator,
}

/// A constraint, consisting of an equation governed by an expression and a relational operator,
/// and an associated strength.
#[derive(Clone, Debug)]
pub struct Constraint {
    inner: Arc<Inner>,
}

impl Constraint {
    /// Construct a new constraint from an expression, a relational operator and a strength.
    /// This corresponds to the equation `e op 0.0`, e.g. `x + y >= 0.0`. For equations with a
    /// non-zero right hand side, subtract it from the equation to give a zero right hand side.
    pub fn new(
        expression: Expression,
        operator: RelationalOperator,
        strength: Strength,
    ) -> Constraint {
        Constraint {
            inner: Arc::new(Inner {
                expression,
                operator,
                strength,
            }),
        }
    }
    /// The expression of the left hand side of the constraint equation.
    pub fn expr(&self) -> &Expression {
        &self.inner.expression
    }
    /// The relational operator governing the constraint.
    pub fn op(&self) -> RelationalOperator {
        self.inner.operator
    }
    /// The strength of the constraint that the solver will use.
    pub fn strength(&self) -> Strength {
        self.inner.strength
    }
}

impl Hash for Constraint {
    fn hash<H: Hasher>(&self, hasher: &mut H) {
        use core::ops::Deref;
        hasher.write_usize(self.inner.deref() as *const _ as usize);
    }
}

impl PartialEq for Constraint {
    fn eq(&self, other: &Constraint) -> bool {
        use core::ops::Deref;
        core::ptr::eq(self.inner.deref(), other.inner.deref())
    }
}

impl Eq for Constraint {}

/// This is an intermediate type used in the syntactic sugar for specifying constraints. You should
/// not use it directly.
pub struct PartialConstraint {
    expression: Expression,
    relation: WeightedRelation,
}

impl PartialConstraint {
    /// Construct a new partial constraint from an expression and a relational operator.
    pub const fn new(expression: Expression, relation: WeightedRelation) -> PartialConstraint {
        PartialConstraint {
            expression,
            relation,
        }
    }
}

impl ops::BitOr<f64> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: f64) -> Constraint {
        let (operator, strength) = self.relation.into();
        #[allow(clippy::suspicious_arithmetic_impl)]
        Constraint::new(self.expression - rhs, operator, strength)
    }
}

impl ops::BitOr<f32> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: f32) -> Constraint {
        self.bitor(rhs as f64)
    }
}

impl ops::BitOr<Variable> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Variable) -> Constraint {
        let (operator, strength) = self.relation.into();
        #[allow(clippy::suspicious_arithmetic_impl)]
        Constraint::new(self.expression - rhs, operator, strength)
    }
}

impl ops::BitOr<Term> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Term) -> Constraint {
        let (operator, strength) = self.relation.into();
        #[allow(clippy::suspicious_arithmetic_impl)]
        Constraint::new(self.expression - rhs, operator, strength)
    }
}

impl ops::BitOr<Expression> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Expression) -> Constraint {
        let (operator, strength) = self.relation.into();
        #[allow(clippy::suspicious_arithmetic_impl)]
        Constraint::new(self.expression - rhs, operator, strength)
    }
}