Struct ComposedVisitor

pub struct ComposedVisitor<'a, Context, A: Visitor<'a, Context>, B: Visitor<'a, Context>> {
    pub a: A,
    pub b: B,
    /* private fields */
}

This structure implements the Visitor trait and runs two child Visitors in parallel, executing and calling callbacks on them both.

During traversal the Composed Visitor will keep track of the visitor’s VisitFlow signals and will avoid calling callbacks on them appropriately, while letting the other visitor continue as usual. In short, this visitor aims to minimize the work it does while preserving expected behavior.

Visitors may be composed indefinitely since a Composed Visitor can be passed into another Composed Visitor, as long as all visitors accept the same Context type.

Fields

a: A

b: B

Implementations

impl<'a, C, A: Visitor<'a, C>, B: Visitor<'a, C>> ComposedVisitor<'a, C, A, B>

pub fn new(a: A, b: B) -> ComposedVisitor<'a, C, A, B>

Composes two input visitors into one Composed Visitor.

Trait Implementations

impl<'a, A, B> Default for ComposedVisitor<'a, ValidationContext<'a>, A, B>

where A: ValidationRule<'a>, B: ValidationRule<'a>,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, A, B> ValidationRule<'a> for ComposedVisitor<'a, ValidationContext<'a>, A, B>

where A: ValidationRule<'a>, B: ValidationRule<'a>,

fn validate(ctx: &'a ASTContext, document: &'a Document<'a>) -> Result<()>

Run this ValidationRule against the given document and return a result which errors if the rule fails on the document.

impl<'a, C, A: Visitor<'a, C>, B: Visitor<'a, C>> Visitor<'a, C> for ComposedVisitor<'a, C, A, B>

fn enter_document( &mut self, ctx: &mut C, document: &'a Document<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a Document is visited and before its child nodes are visited.

fn leave_document( &mut self, ctx: &mut C, document: &'a Document<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a Document and its child nodes were visited.

fn enter_operation( &mut self, ctx: &mut C, operation: &'a OperationDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called when an OperationDefinition node is visited and before its child nodes are visited.

fn leave_operation( &mut self, ctx: &mut C, operation: &'a OperationDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called after an OperationDefinition and its child node were visited.

fn enter_fragment( &mut self, ctx: &mut C, fragment: &'a FragmentDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a FragmentDefinition node is visited and before its child nodes are visited.

fn leave_fragment( &mut self, ctx: &mut C, fragment: &'a FragmentDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a FragmentDefinition node and its child nodes were visited.

fn enter_variable_definition( &mut self, ctx: &mut C, var_def: &'a VariableDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a VariableDefinition node is visited and before its child nodes are visited.

fn leave_variable_definition( &mut self, ctx: &mut C, var_def: &'a VariableDefinition<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a VariableDefinition node and its child nodes were visited.

fn enter_selection_set( &mut self, ctx: &mut C, selection_set: &'a SelectionSet<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a SelectionSet node is visited and before its child nodes are visited.

fn leave_selection_set( &mut self, ctx: &mut C, selection_set: &'a SelectionSet<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a SelectionSet node and its child nodes were visited.

fn enter_fragment_spread( &mut self, ctx: &mut C, fragment_spread: &'a FragmentSpread<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a FragmentSpread node is visited and before its child nodes are visited.

fn leave_fragment_spread( &mut self, ctx: &mut C, fragment_spread: &'a FragmentSpread<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a FragmentSpread node and its child nodes were visited.

fn enter_inline_fragment( &mut self, ctx: &mut C, inline_fragment: &'a InlineFragment<'a>, info: &VisitInfo, ) -> VisitFlow

Called when an InlineFragment node is visited and before its child nodes are visited.

fn leave_inline_fragment( &mut self, ctx: &mut C, inline_fragment: &'a InlineFragment<'a>, info: &VisitInfo, ) -> VisitFlow

Called after an InlineFragment node and its child nodes were visited.

fn enter_field( &mut self, ctx: &mut C, field: &'a Field<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a Field node is visited and before its child nodes are visited.

fn leave_field( &mut self, ctx: &mut C, field: &'a Field<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a Field node and its child nodes were visited.

fn enter_directive( &mut self, ctx: &mut C, directive: &'a Directive<'a>, info: &VisitInfo, ) -> VisitFlow

Called when a Directive node is visited and before its child nodes are visited.

fn leave_directive( &mut self, ctx: &mut C, directive: &'a Directive<'a>, info: &VisitInfo, ) -> VisitFlow

Called after a Directive node and its child nodes were visited.

fn enter_argument( &mut self, ctx: &mut C, argument: &'a Argument<'a>, info: &VisitInfo, ) -> VisitFlow

Called when an Argument node is visited and before its child nodes are visited.

fn leave_argument( &mut self, ctx: &mut C, argument: &'a Argument<'a>, info: &VisitInfo, ) -> VisitFlow

Called after an Argument node and its child nodes were visited.

fn compose<V: Visitor<'a, Context>>( self, other: V, ) -> ComposedVisitor<'a, Context, Self, V>

Combines two visitors into one that will run both the original and passed visitor concurrently.