flowlog-build 0.3.4

Build-time FlowLog compiler for library mode.
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

//! Comparison expression signatures for FlowLog Datalog programs.

use crate::catalog::{arithmetic::ArithmeticPos, atom::AtomArgumentSignature};
use crate::parser::{ComparisonExpr, ComparisonOperator};
use std::fmt;

/// A comparison expression with variables resolved to their concrete positions.
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub(crate) struct ComparisonExprPos {
    left: ArithmeticPos,
    operator: ComparisonOperator,
    right: ArithmeticPos,
}

impl ComparisonExprPos {
    /// Constructs a positional comparison expression from a parsed expression.
    pub(crate) fn from_comparison_expr(
        compare_expr: &ComparisonExpr,
        left_var_signatures: &[AtomArgumentSignature],
        right_var_signatures: &[AtomArgumentSignature],
    ) -> Self {
        let left = ArithmeticPos::from_arithmetic(compare_expr.left(), left_var_signatures);
        let right = ArithmeticPos::from_arithmetic(compare_expr.right(), right_var_signatures);
        let operator = compare_expr.operator().clone();

        Self {
            left,
            operator,
            right,
        }
    }

    /// Construct a positional comparison expression directly from parts.
    pub(crate) fn from_parts(
        left: ArithmeticPos,
        operator: ComparisonOperator,
        right: ArithmeticPos,
    ) -> Self {
        Self {
            left,
            operator,
            right,
        }
    }

    /// Returns the comparison operator.
    #[inline]
    pub(crate) fn operator(&self) -> &ComparisonOperator {
        &self.operator
    }

    /// Returns the left-hand side arithmetic expression.
    #[inline]
    pub(crate) fn left(&self) -> &ArithmeticPos {
        &self.left
    }

    /// Returns the right-hand side arithmetic expression.
    #[inline]
    pub(crate) fn right(&self) -> &ArithmeticPos {
        &self.right
    }
}

impl fmt::Display for ComparisonExprPos {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{} {} {}]", self.left, self.operator, self.right)
    }
}