hamelin_lib 0.15.4

Core library for Hamelin query language
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

use crate::tree::ast::expression::{Expression, FieldLookup, IndexAccess};
use crate::tree::ast::identifier::{ParsedSimpleIdentifier, SimpleIdentifier};
use crate::tree::ast::node::Span;
use crate::tree::builder::{ExpressionBuilder, IntoExpressionBuilder};
use std::sync::Arc;

/// Builder for field lookup expressions (e.g., value.field)
#[derive(Debug)]
pub struct FieldLookupBuilder {
    operand: Box<dyn ExpressionBuilder>,
    field: String,
}

impl FieldLookupBuilder {
    pub fn new(operand: impl IntoExpressionBuilder, field: &str) -> Self {
        Self {
            operand: operand.into_expression_builder(),
            field: field.to_string(),
        }
    }
}

impl ExpressionBuilder for FieldLookupBuilder {
    fn build(&self) -> Expression {
        Expression {
            span: Span::NONE,
            kind: FieldLookup {
                value: Arc::new(self.operand.build()),
                field_identifier: ParsedSimpleIdentifier::Valid(SimpleIdentifier::new(&self.field)),
            }
            .into(),
        }
    }
}

impl IntoExpressionBuilder for FieldLookupBuilder {
    fn into_expression_builder(self) -> Box<dyn ExpressionBuilder> {
        Box::new(self)
    }
}

/// Builder for index access expressions (e.g., value[index])
#[derive(Debug)]
pub struct IndexAccessBuilder {
    operand: Box<dyn ExpressionBuilder>,
    index: Box<dyn ExpressionBuilder>,
}

impl IndexAccessBuilder {
    pub fn new(operand: impl IntoExpressionBuilder, index: impl IntoExpressionBuilder) -> Self {
        Self {
            operand: operand.into_expression_builder(),
            index: index.into_expression_builder(),
        }
    }
}

impl ExpressionBuilder for IndexAccessBuilder {
    fn build(&self) -> Expression {
        Expression {
            span: Span::NONE,
            kind: IndexAccess {
                value: Arc::new(self.operand.build()),
                index: Arc::new(self.index.build()),
            }
            .into(),
        }
    }
}

impl IntoExpressionBuilder for IndexAccessBuilder {
    fn into_expression_builder(self) -> Box<dyn ExpressionBuilder> {
        Box::new(self)
    }
}

// Convenience functions
pub fn field(operand: impl IntoExpressionBuilder, field_name: &str) -> FieldLookupBuilder {
    FieldLookupBuilder::new(operand, field_name)
}

pub fn index(
    operand: impl IntoExpressionBuilder,
    idx: impl IntoExpressionBuilder,
) -> IndexAccessBuilder {
    IndexAccessBuilder::new(operand, idx)
}