Struct LimitTracker 

pub struct LimitTracker {
    pub high: usize,
    pub limit: usize,
    /* private fields */
}

A LimitTracker enforces a particular limit within the parser. It keeps track of utilization so that we can report how close to a limit we approached over the lifetime of the tracker.

use oxc_graphql_parser::{Allocator, Parser};

let query = "
{
    animal
    ...snackSelection
    ... on Pet {
      playmates {
        count
      }
    }
}
";
// Create a new instance of a parser given a query and a
// recursion limit
let allocator = Allocator::default();
let parser = Parser::new(&allocator, query).recursion_limit(4);
// Parse the query, and return an AST.
let ast = parser.parse();
// Retrieve the limits
let usage = ast.recursion_limit();
// Print out some of the usage details to see what happened during
// our parse. `limit` just reports the limit we set, `high` is the
// high-water mark of recursion usage.
println!("{:?}", usage);
println!("{:?}", usage.limit);
println!("{:?}", usage.high);
// Check that are no errors. These are not part of the AST.
assert_eq!(0, ast.errors().len());

// Get the document root node
let doc = ast.document();
// ... continue

Fields

high: usize

High Water mark for this limit

limit: usize

Limit.

Implementations

impl LimitTracker

pub fn new(limit: usize) -> Self

pub fn check_and_increment(&mut self) -> bool

Return whether the limit was reached

pub fn decrement(&mut self)

Trait Implementations

impl Clone for LimitTracker

fn clone(&self) -> LimitTracker

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for LimitTracker

impl Debug for LimitTracker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LimitTracker

impl PartialEq for LimitTracker

fn eq(&self, other: &LimitTracker) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LimitTracker