bluejay-parser 0.3.1

A GraphQL parser
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

use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens, Value};
use crate::lexical_token::{Name, PunctuatorType};
use crate::{HasSpan, Span};

#[derive(Debug)]
pub struct Argument<'a, const CONST: bool> {
    name: Name<'a>,
    value: Value<'a, CONST>,
    span: Span,
}

impl<'a, const CONST: bool> Argument<'a, CONST> {
    pub fn name(&self) -> &Name<'a> {
        &self.name
    }

    pub fn value(&self) -> &Value<'a, CONST> {
        &self.value
    }
}

pub type ConstArgument<'a> = Argument<'a, true>;
pub type VariableArgument<'a> = Argument<'a, false>;

impl<'a, const CONST: bool> FromTokens<'a> for Argument<'a, CONST> {
    #[inline]
    fn from_tokens(
        tokens: &mut impl Tokens<'a>,
        depth_limiter: DepthLimiter,
    ) -> Result<Self, ParseError> {
        let name = tokens.expect_name()?;
        tokens.expect_punctuator(PunctuatorType::Colon)?;
        let value = Value::from_tokens(tokens, depth_limiter.bump()?)?;
        let span = name.span().merge(value.span());
        Ok(Self { name, value, span })
    }
}

impl<'a, const CONST: bool> bluejay_core::Argument<CONST> for Argument<'a, CONST> {
    type Value = Value<'a, CONST>;

    fn name(&self) -> &str {
        self.name.as_ref()
    }

    fn value(&self) -> &Value<'a, CONST> {
        &self.value
    }
}

impl<const CONST: bool> HasSpan for Argument<'_, CONST> {
    fn span(&self) -> &Span {
        &self.span
    }
}