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
use super::Expression;
use crate::Identifier;
use serde::Deserialize;
/// A for expression is a construct for constructing a collection by projecting the items from
/// another collection.
#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct ForExpr {
/// Optional name of the variable that will be temporarily assigned the key of each element
/// during iteration. If the source collection is an array, it gets assigned the zero-based
/// array index. For an object source collection, this gets assigned the object's key.
pub key_var: Option<Identifier>,
/// The name of the variable that will be temporarily assigned the value of each element
/// during iteration.
pub value_var: Identifier,
/// An expression that must evaluate to a value that can be iterated.
pub collection_expr: Expression,
/// An expression that is evaluated once for each key in the source collection. If set, the
/// result of the `for` expression will be an object. Otherwise, the result will be an array.
pub key_expr: Option<Expression>,
/// An expression that is evaluated once for each value in the source collection.
pub value_expr: Expression,
/// Indicates whether grouping mode is enabled. In grouping mode, each value in the resulting
/// object is a list of all of the values that were produced against each distinct key. This is
/// ignored if `key_expr` is `None`.
pub grouping: bool,
/// An optional filter expression. Elements for which the condition evaluates to `true` will
/// be evaluated as normal, while if `false` the element will be skipped.
pub cond_expr: Option<Expression>,
}
impl ForExpr {
/// Create a new `ForExpr` with the name of the variable that will be temporarily assigned the
/// value of each element during iteration, an expression that must evaluate to a value that
/// can be iterated, and one expression that is evaluated once for each value in the source
/// collection.
pub fn new<C, V>(value_var: Identifier, collection_expr: C, value_expr: V) -> ForExpr
where
C: Into<Expression>,
V: Into<Expression>,
{
ForExpr {
key_var: None,
value_var,
collection_expr: collection_expr.into(),
key_expr: None,
value_expr: value_expr.into(),
grouping: false,
cond_expr: None,
}
}
/// Adds the iterator key variable identifier to the `for` expression and returns the modified
/// `ForExpr`.
pub fn with_key_var(mut self, key_var: Identifier) -> ForExpr {
self.key_var = Some(key_var);
self
}
/// Adds an expression that is evaluated once for each key in the source collection. If set,
/// the result of the `for` expression will be an object. Returns the modified `ForExpr`.
pub fn with_key_expr<T>(mut self, key_expr: T) -> ForExpr
where
T: Into<Expression>,
{
self.key_expr = Some(key_expr.into());
self
}
/// Sets the filter expression. Elements for which the condition evaluates to `true` will be
/// evaluated as normal, while if `false` the element will be skipped.
pub fn with_cond_expr<T>(mut self, cond_expr: T) -> ForExpr
where
T: Into<Expression>,
{
self.cond_expr = Some(cond_expr.into());
self
}
/// Enables or disabled grouping mode.
pub fn with_grouping(mut self, yes: bool) -> ForExpr {
self.grouping = yes;
self
}
}