Traqula
    Preparing search index...

    Variable visitOperationSubConst

    visitOperationSub: (
        startObject: object,
        nodeCallBacks: {
            add?: {
                preVisitor?: (op: Algebra.Add) => VisitContext;
                visitor?: (op: Algebra.Add) => void;
            };
            alt?: {
                preVisitor?: (op: Algebra.Alt) => VisitContext;
                visitor?: (op: Algebra.Alt) => void;
            };
            ask?: {
                preVisitor?: (op: Algebra.Ask) => VisitContext;
                visitor?: (op: Algebra.Ask) => void;
            };
            bgp?: {
                preVisitor?: (op: Algebra.Bgp) => VisitContext;
                visitor?: (op: Algebra.Bgp) => void;
            };
            clear?: {
                preVisitor?: (op: Algebra.Clear) => VisitContext;
                visitor?: (op: Algebra.Clear) => void;
            };
            compositeupdate?: {
                preVisitor?: (op: Algebra.CompositeUpdate) => VisitContext;
                visitor?: (op: Algebra.CompositeUpdate) => void;
            };
            construct?: {
                preVisitor?: (op: Algebra.Construct) => VisitContext;
                visitor?: (op: Algebra.Construct) => void;
            };
            copy?: {
                preVisitor?: (op: Algebra.Copy) => VisitContext;
                visitor?: (op: Algebra.Copy) => void;
            };
            create?: {
                preVisitor?: (op: Algebra.Create) => VisitContext;
                visitor?: (op: Algebra.Create) => void;
            };
            deleteinsert?: {
                preVisitor?: (op: Algebra.DeleteInsert) => VisitContext;
                visitor?: (op: Algebra.DeleteInsert) => void;
            };
            describe?: {
                preVisitor?: (op: Algebra.Describe) => VisitContext;
                visitor?: (op: Algebra.Describe) => void;
            };
            distinct?: {
                preVisitor?: (op: Algebra.Distinct) => VisitContext;
                visitor?: (op: Algebra.Distinct) => void;
            };
            drop?: {
                preVisitor?: (op: Algebra.Drop) => VisitContext;
                visitor?: (op: Algebra.Drop) => void;
            };
            expression?: {
                preVisitor?: (op: Algebra.Expression) => VisitContext;
                visitor?: (op: Algebra.Expression) => void;
            };
            extend?: {
                preVisitor?: (op: Algebra.Extend) => VisitContext;
                visitor?: (op: Algebra.Extend) => void;
            };
            filter?: {
                preVisitor?: (op: Algebra.Filter) => VisitContext;
                visitor?: (op: Algebra.Filter) => void;
            };
            from?: {
                preVisitor?: (op: Algebra.From) => VisitContext;
                visitor?: (op: Algebra.From) => void;
            };
            graph?: {
                preVisitor?: (op: Algebra.Graph) => VisitContext;
                visitor?: (op: Algebra.Graph) => void;
            };
            group?: {
                preVisitor?: (op: Algebra.Group) => VisitContext;
                visitor?: (op: Algebra.Group) => void;
            };
            inv?: {
                preVisitor?: (op: Algebra.Inv) => VisitContext;
                visitor?: (op: Algebra.Inv) => void;
            };
            join?: {
                preVisitor?: (op: Algebra.Join) => VisitContext;
                visitor?: (op: Algebra.Join) => void;
            };
            leftjoin?: {
                preVisitor?: (op: Algebra.LeftJoin) => VisitContext;
                visitor?: (op: Algebra.LeftJoin) => void;
            };
            link?: {
                preVisitor?: (op: Algebra.Link) => VisitContext;
                visitor?: (op: Algebra.Link) => void;
            };
            load?: {
                preVisitor?: (op: Algebra.Load) => VisitContext;
                visitor?: (op: Algebra.Load) => void;
            };
            minus?: {
                preVisitor?: (op: Algebra.Minus) => VisitContext;
                visitor?: (op: Algebra.Minus) => void;
            };
            move?: {
                preVisitor?: (op: Algebra.Move) => VisitContext;
                visitor?: (op: Algebra.Move) => void;
            };
            nop?: {
                preVisitor?: (op: Algebra.Nop) => VisitContext;
                visitor?: (op: Algebra.Nop) => void;
            };
            nps?: {
                preVisitor?: (op: Algebra.Nps) => VisitContext;
                visitor?: (op: Algebra.Nps) => void;
            };
            OneOrMorePath?: {
                preVisitor?: (op: Algebra.OneOrMorePath) => VisitContext;
                visitor?: (op: Algebra.OneOrMorePath) => void;
            };
            orderby?: {
                preVisitor?: (op: Algebra.OrderBy) => VisitContext;
                visitor?: (op: Algebra.OrderBy) => void;
            };
            path?: {
                preVisitor?: (op: Algebra.Path) => VisitContext;
                visitor?: (op: Algebra.Path) => void;
            };
            pattern?: {
                preVisitor?: (op: Algebra.Pattern) => VisitContext;
                visitor?: (op: Algebra.Pattern) => void;
            };
            project?: {
                preVisitor?: (op: Algebra.Project) => VisitContext;
                visitor?: (op: Algebra.Project) => void;
            };
            reduced?: {
                preVisitor?: (op: Algebra.Reduced) => VisitContext;
                visitor?: (op: Algebra.Reduced) => void;
            };
            seq?: {
                preVisitor?: (op: Algebra.Seq) => VisitContext;
                visitor?: (op: Algebra.Seq) => void;
            };
            service?: {
                preVisitor?: (op: Algebra.Service) => VisitContext;
                visitor?: (op: Algebra.Service) => void;
            };
            slice?: {
                preVisitor?: (op: Algebra.Slice) => VisitContext;
                visitor?: (op: Algebra.Slice) => void;
            };
            union?: {
                preVisitor?: (op: Algebra.Union) => VisitContext;
                visitor?: (op: Algebra.Union) => void;
            };
            values?: {
                preVisitor?: (op: Algebra.Values) => VisitContext;
                visitor?: (op: Algebra.Values) => void;
            };
            ZeroOrMorePath?: {
                preVisitor?: (op: Algebra.ZeroOrMorePath) => VisitContext;
                visitor?: (op: Algebra.ZeroOrMorePath) => void;
            };
            ZeroOrOnePath?: {
                preVisitor?: (op: Algebra.ZeroOrOnePath) => VisitContext;
                visitor?: (op: Algebra.ZeroOrOnePath) => void;
            };
        },
        nodeSpecificCallBacks: {
            add?: {};
            alt?: {};
            ask?: {};
            bgp?: {};
            clear?: {};
            compositeupdate?: {};
            construct?: {};
            copy?: {};
            create?: {};
            deleteinsert?: {};
            describe?: {};
            distinct?: {};
            drop?: {};
            expression?: {
                aggregate?: {
                    preVisitor?: (
                        op:
                            | Algebra.AggregateExpression
                            | Algebra.GroupConcatExpression
                            | Algebra.BoundAggregate,
                    ) => VisitContext;
                    visitor?: (
                        op:
                            | Algebra.AggregateExpression
                            | Algebra.GroupConcatExpression
                            | Algebra.BoundAggregate,
                    ) => void;
                };
                existence?: {
                    preVisitor?: (op: Algebra.ExistenceExpression) => VisitContext;
                    visitor?: (op: Algebra.ExistenceExpression) => void;
                };
                named?: {
                    preVisitor?: (op: Algebra.NamedExpression) => VisitContext;
                    visitor?: (op: Algebra.NamedExpression) => void;
                };
                operator?: {
                    preVisitor?: (op: Algebra.OperatorExpression) => VisitContext;
                    visitor?: (op: Algebra.OperatorExpression) => void;
                };
                term?: {
                    preVisitor?: (op: Algebra.TermExpression) => VisitContext;
                    visitor?: (op: Algebra.TermExpression) => void;
                };
                wildcard?: {
                    preVisitor?: (op: Algebra.WildcardExpression) => VisitContext;
                    visitor?: (op: Algebra.WildcardExpression) => void;
                };
            };
            extend?: {};
            filter?: {};
            from?: {};
            graph?: {};
            group?: {};
            inv?: {};
            join?: {};
            leftjoin?: {};
            link?: {};
            load?: {};
            minus?: {};
            move?: {};
            nop?: {};
            nps?: {};
            OneOrMorePath?: {};
            orderby?: {};
            path?: {};
            pattern?: {};
            project?: {};
            reduced?: {};
            seq?: {};
            service?: {};
            slice?: {};
            union?: {};
            values?: {};
            ZeroOrMorePath?: {};
            ZeroOrOnePath?: {};
        },
    ) => void = ...

    Visits an object and it's descendants, similar to visitOperation, but also allowing you to target subTypes. e.g.: e.g.:

    visitOperationSub({
      type: Algebra.Types.DISTINCT,
      input: {
        type: Algebra.Types.DISTINCT,
        subType: 'special',
      },
    }, {
      [Algebra.Types.DISTINCT]: {
        visitor: () => console.log('1'),
        preVisitor: () => {
          console.log('2');
          return {};
        },
      },
    }, {
      [Algebra.Types.DISTINCT]: { special: {
        visitor: () => console.log('3'),
      }},
    });

    Will call the preVisitor on the outer distinct, then the visitor of the special distinct, followed by the visiting the outer distinct, printing '231'. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.

    Type Declaration

      • (
            startObject: object,
            nodeCallBacks: {
                add?: {
                    preVisitor?: (op: Algebra.Add) => VisitContext;
                    visitor?: (op: Algebra.Add) => void;
                };
                alt?: {
                    preVisitor?: (op: Algebra.Alt) => VisitContext;
                    visitor?: (op: Algebra.Alt) => void;
                };
                ask?: {
                    preVisitor?: (op: Algebra.Ask) => VisitContext;
                    visitor?: (op: Algebra.Ask) => void;
                };
                bgp?: {
                    preVisitor?: (op: Algebra.Bgp) => VisitContext;
                    visitor?: (op: Algebra.Bgp) => void;
                };
                clear?: {
                    preVisitor?: (op: Algebra.Clear) => VisitContext;
                    visitor?: (op: Algebra.Clear) => void;
                };
                compositeupdate?: {
                    preVisitor?: (op: Algebra.CompositeUpdate) => VisitContext;
                    visitor?: (op: Algebra.CompositeUpdate) => void;
                };
                construct?: {
                    preVisitor?: (op: Algebra.Construct) => VisitContext;
                    visitor?: (op: Algebra.Construct) => void;
                };
                copy?: {
                    preVisitor?: (op: Algebra.Copy) => VisitContext;
                    visitor?: (op: Algebra.Copy) => void;
                };
                create?: {
                    preVisitor?: (op: Algebra.Create) => VisitContext;
                    visitor?: (op: Algebra.Create) => void;
                };
                deleteinsert?: {
                    preVisitor?: (op: Algebra.DeleteInsert) => VisitContext;
                    visitor?: (op: Algebra.DeleteInsert) => void;
                };
                describe?: {
                    preVisitor?: (op: Algebra.Describe) => VisitContext;
                    visitor?: (op: Algebra.Describe) => void;
                };
                distinct?: {
                    preVisitor?: (op: Algebra.Distinct) => VisitContext;
                    visitor?: (op: Algebra.Distinct) => void;
                };
                drop?: {
                    preVisitor?: (op: Algebra.Drop) => VisitContext;
                    visitor?: (op: Algebra.Drop) => void;
                };
                expression?: {
                    preVisitor?: (op: Algebra.Expression) => VisitContext;
                    visitor?: (op: Algebra.Expression) => void;
                };
                extend?: {
                    preVisitor?: (op: Algebra.Extend) => VisitContext;
                    visitor?: (op: Algebra.Extend) => void;
                };
                filter?: {
                    preVisitor?: (op: Algebra.Filter) => VisitContext;
                    visitor?: (op: Algebra.Filter) => void;
                };
                from?: {
                    preVisitor?: (op: Algebra.From) => VisitContext;
                    visitor?: (op: Algebra.From) => void;
                };
                graph?: {
                    preVisitor?: (op: Algebra.Graph) => VisitContext;
                    visitor?: (op: Algebra.Graph) => void;
                };
                group?: {
                    preVisitor?: (op: Algebra.Group) => VisitContext;
                    visitor?: (op: Algebra.Group) => void;
                };
                inv?: {
                    preVisitor?: (op: Algebra.Inv) => VisitContext;
                    visitor?: (op: Algebra.Inv) => void;
                };
                join?: {
                    preVisitor?: (op: Algebra.Join) => VisitContext;
                    visitor?: (op: Algebra.Join) => void;
                };
                leftjoin?: {
                    preVisitor?: (op: Algebra.LeftJoin) => VisitContext;
                    visitor?: (op: Algebra.LeftJoin) => void;
                };
                link?: {
                    preVisitor?: (op: Algebra.Link) => VisitContext;
                    visitor?: (op: Algebra.Link) => void;
                };
                load?: {
                    preVisitor?: (op: Algebra.Load) => VisitContext;
                    visitor?: (op: Algebra.Load) => void;
                };
                minus?: {
                    preVisitor?: (op: Algebra.Minus) => VisitContext;
                    visitor?: (op: Algebra.Minus) => void;
                };
                move?: {
                    preVisitor?: (op: Algebra.Move) => VisitContext;
                    visitor?: (op: Algebra.Move) => void;
                };
                nop?: {
                    preVisitor?: (op: Algebra.Nop) => VisitContext;
                    visitor?: (op: Algebra.Nop) => void;
                };
                nps?: {
                    preVisitor?: (op: Algebra.Nps) => VisitContext;
                    visitor?: (op: Algebra.Nps) => void;
                };
                OneOrMorePath?: {
                    preVisitor?: (op: Algebra.OneOrMorePath) => VisitContext;
                    visitor?: (op: Algebra.OneOrMorePath) => void;
                };
                orderby?: {
                    preVisitor?: (op: Algebra.OrderBy) => VisitContext;
                    visitor?: (op: Algebra.OrderBy) => void;
                };
                path?: {
                    preVisitor?: (op: Algebra.Path) => VisitContext;
                    visitor?: (op: Algebra.Path) => void;
                };
                pattern?: {
                    preVisitor?: (op: Algebra.Pattern) => VisitContext;
                    visitor?: (op: Algebra.Pattern) => void;
                };
                project?: {
                    preVisitor?: (op: Algebra.Project) => VisitContext;
                    visitor?: (op: Algebra.Project) => void;
                };
                reduced?: {
                    preVisitor?: (op: Algebra.Reduced) => VisitContext;
                    visitor?: (op: Algebra.Reduced) => void;
                };
                seq?: {
                    preVisitor?: (op: Algebra.Seq) => VisitContext;
                    visitor?: (op: Algebra.Seq) => void;
                };
                service?: {
                    preVisitor?: (op: Algebra.Service) => VisitContext;
                    visitor?: (op: Algebra.Service) => void;
                };
                slice?: {
                    preVisitor?: (op: Algebra.Slice) => VisitContext;
                    visitor?: (op: Algebra.Slice) => void;
                };
                union?: {
                    preVisitor?: (op: Algebra.Union) => VisitContext;
                    visitor?: (op: Algebra.Union) => void;
                };
                values?: {
                    preVisitor?: (op: Algebra.Values) => VisitContext;
                    visitor?: (op: Algebra.Values) => void;
                };
                ZeroOrMorePath?: {
                    preVisitor?: (op: Algebra.ZeroOrMorePath) => VisitContext;
                    visitor?: (op: Algebra.ZeroOrMorePath) => void;
                };
                ZeroOrOnePath?: {
                    preVisitor?: (op: Algebra.ZeroOrOnePath) => VisitContext;
                    visitor?: (op: Algebra.ZeroOrOnePath) => void;
                };
            },
            nodeSpecificCallBacks: {
                add?: {};
                alt?: {};
                ask?: {};
                bgp?: {};
                clear?: {};
                compositeupdate?: {};
                construct?: {};
                copy?: {};
                create?: {};
                deleteinsert?: {};
                describe?: {};
                distinct?: {};
                drop?: {};
                expression?: {
                    aggregate?: {
                        preVisitor?: (
                            op:
                                | Algebra.AggregateExpression
                                | Algebra.GroupConcatExpression
                                | Algebra.BoundAggregate,
                        ) => VisitContext;
                        visitor?: (
                            op:
                                | Algebra.AggregateExpression
                                | Algebra.GroupConcatExpression
                                | Algebra.BoundAggregate,
                        ) => void;
                    };
                    existence?: {
                        preVisitor?: (op: Algebra.ExistenceExpression) => VisitContext;
                        visitor?: (op: Algebra.ExistenceExpression) => void;
                    };
                    named?: {
                        preVisitor?: (op: Algebra.NamedExpression) => VisitContext;
                        visitor?: (op: Algebra.NamedExpression) => void;
                    };
                    operator?: {
                        preVisitor?: (op: Algebra.OperatorExpression) => VisitContext;
                        visitor?: (op: Algebra.OperatorExpression) => void;
                    };
                    term?: {
                        preVisitor?: (op: Algebra.TermExpression) => VisitContext;
                        visitor?: (op: Algebra.TermExpression) => void;
                    };
                    wildcard?: {
                        preVisitor?: (op: Algebra.WildcardExpression) => VisitContext;
                        visitor?: (op: Algebra.WildcardExpression) => void;
                    };
                };
                extend?: {};
                filter?: {};
                from?: {};
                graph?: {};
                group?: {};
                inv?: {};
                join?: {};
                leftjoin?: {};
                link?: {};
                load?: {};
                minus?: {};
                move?: {};
                nop?: {};
                nps?: {};
                OneOrMorePath?: {};
                orderby?: {};
                path?: {};
                pattern?: {};
                project?: {};
                reduced?: {};
                seq?: {};
                service?: {};
                slice?: {};
                union?: {};
                values?: {};
                ZeroOrMorePath?: {};
                ZeroOrOnePath?: {};
            },
        ): void

      • Visit a selected subTree given a startObject, steering the visits based on Typed nodes. Similar to this.visitNode, but also allowing you to target subTypes. Will call the preVisitor on the outer distinct, then the visitor of the special distinct, followed by the visiting the outer distinct, printing '231'. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.

        Parameters

        • startObject: object

          the object from which we will start visiting, potentially visiting its descendants along the way.

        • nodeCallBacks: {
              add?: {
                  preVisitor?: (op: Algebra.Add) => VisitContext;
                  visitor?: (op: Algebra.Add) => void;
              };
              alt?: {
                  preVisitor?: (op: Algebra.Alt) => VisitContext;
                  visitor?: (op: Algebra.Alt) => void;
              };
              ask?: {
                  preVisitor?: (op: Algebra.Ask) => VisitContext;
                  visitor?: (op: Algebra.Ask) => void;
              };
              bgp?: {
                  preVisitor?: (op: Algebra.Bgp) => VisitContext;
                  visitor?: (op: Algebra.Bgp) => void;
              };
              clear?: {
                  preVisitor?: (op: Algebra.Clear) => VisitContext;
                  visitor?: (op: Algebra.Clear) => void;
              };
              compositeupdate?: {
                  preVisitor?: (op: Algebra.CompositeUpdate) => VisitContext;
                  visitor?: (op: Algebra.CompositeUpdate) => void;
              };
              construct?: {
                  preVisitor?: (op: Algebra.Construct) => VisitContext;
                  visitor?: (op: Algebra.Construct) => void;
              };
              copy?: {
                  preVisitor?: (op: Algebra.Copy) => VisitContext;
                  visitor?: (op: Algebra.Copy) => void;
              };
              create?: {
                  preVisitor?: (op: Algebra.Create) => VisitContext;
                  visitor?: (op: Algebra.Create) => void;
              };
              deleteinsert?: {
                  preVisitor?: (op: Algebra.DeleteInsert) => VisitContext;
                  visitor?: (op: Algebra.DeleteInsert) => void;
              };
              describe?: {
                  preVisitor?: (op: Algebra.Describe) => VisitContext;
                  visitor?: (op: Algebra.Describe) => void;
              };
              distinct?: {
                  preVisitor?: (op: Algebra.Distinct) => VisitContext;
                  visitor?: (op: Algebra.Distinct) => void;
              };
              drop?: {
                  preVisitor?: (op: Algebra.Drop) => VisitContext;
                  visitor?: (op: Algebra.Drop) => void;
              };
              expression?: {
                  preVisitor?: (op: Algebra.Expression) => VisitContext;
                  visitor?: (op: Algebra.Expression) => void;
              };
              extend?: {
                  preVisitor?: (op: Algebra.Extend) => VisitContext;
                  visitor?: (op: Algebra.Extend) => void;
              };
              filter?: {
                  preVisitor?: (op: Algebra.Filter) => VisitContext;
                  visitor?: (op: Algebra.Filter) => void;
              };
              from?: {
                  preVisitor?: (op: Algebra.From) => VisitContext;
                  visitor?: (op: Algebra.From) => void;
              };
              graph?: {
                  preVisitor?: (op: Algebra.Graph) => VisitContext;
                  visitor?: (op: Algebra.Graph) => void;
              };
              group?: {
                  preVisitor?: (op: Algebra.Group) => VisitContext;
                  visitor?: (op: Algebra.Group) => void;
              };
              inv?: {
                  preVisitor?: (op: Algebra.Inv) => VisitContext;
                  visitor?: (op: Algebra.Inv) => void;
              };
              join?: {
                  preVisitor?: (op: Algebra.Join) => VisitContext;
                  visitor?: (op: Algebra.Join) => void;
              };
              leftjoin?: {
                  preVisitor?: (op: Algebra.LeftJoin) => VisitContext;
                  visitor?: (op: Algebra.LeftJoin) => void;
              };
              link?: {
                  preVisitor?: (op: Algebra.Link) => VisitContext;
                  visitor?: (op: Algebra.Link) => void;
              };
              load?: {
                  preVisitor?: (op: Algebra.Load) => VisitContext;
                  visitor?: (op: Algebra.Load) => void;
              };
              minus?: {
                  preVisitor?: (op: Algebra.Minus) => VisitContext;
                  visitor?: (op: Algebra.Minus) => void;
              };
              move?: {
                  preVisitor?: (op: Algebra.Move) => VisitContext;
                  visitor?: (op: Algebra.Move) => void;
              };
              nop?: {
                  preVisitor?: (op: Algebra.Nop) => VisitContext;
                  visitor?: (op: Algebra.Nop) => void;
              };
              nps?: {
                  preVisitor?: (op: Algebra.Nps) => VisitContext;
                  visitor?: (op: Algebra.Nps) => void;
              };
              OneOrMorePath?: {
                  preVisitor?: (op: Algebra.OneOrMorePath) => VisitContext;
                  visitor?: (op: Algebra.OneOrMorePath) => void;
              };
              orderby?: {
                  preVisitor?: (op: Algebra.OrderBy) => VisitContext;
                  visitor?: (op: Algebra.OrderBy) => void;
              };
              path?: {
                  preVisitor?: (op: Algebra.Path) => VisitContext;
                  visitor?: (op: Algebra.Path) => void;
              };
              pattern?: {
                  preVisitor?: (op: Algebra.Pattern) => VisitContext;
                  visitor?: (op: Algebra.Pattern) => void;
              };
              project?: {
                  preVisitor?: (op: Algebra.Project) => VisitContext;
                  visitor?: (op: Algebra.Project) => void;
              };
              reduced?: {
                  preVisitor?: (op: Algebra.Reduced) => VisitContext;
                  visitor?: (op: Algebra.Reduced) => void;
              };
              seq?: {
                  preVisitor?: (op: Algebra.Seq) => VisitContext;
                  visitor?: (op: Algebra.Seq) => void;
              };
              service?: {
                  preVisitor?: (op: Algebra.Service) => VisitContext;
                  visitor?: (op: Algebra.Service) => void;
              };
              slice?: {
                  preVisitor?: (op: Algebra.Slice) => VisitContext;
                  visitor?: (op: Algebra.Slice) => void;
              };
              union?: {
                  preVisitor?: (op: Algebra.Union) => VisitContext;
                  visitor?: (op: Algebra.Union) => void;
              };
              values?: {
                  preVisitor?: (op: Algebra.Values) => VisitContext;
                  visitor?: (op: Algebra.Values) => void;
              };
              ZeroOrMorePath?: {
                  preVisitor?: (op: Algebra.ZeroOrMorePath) => VisitContext;
                  visitor?: (op: Algebra.ZeroOrMorePath) => void;
              };
              ZeroOrOnePath?: {
                  preVisitor?: (op: Algebra.ZeroOrOnePath) => VisitContext;
                  visitor?: (op: Algebra.ZeroOrOnePath) => void;
              };
          }

          a dictionary mapping the various operation types to objects optionally containing preVisitor and visitor. The preVisitor allows you to provide VisitContext for the current object, altering how it will be visited. The visitor allows you to visit the object from deepest to the outermost object. This is useful if you for example want to manipulate the objects you visit during your visits, similar to mapOperation.

        • nodeSpecificCallBacks: {
              add?: {};
              alt?: {};
              ask?: {};
              bgp?: {};
              clear?: {};
              compositeupdate?: {};
              construct?: {};
              copy?: {};
              create?: {};
              deleteinsert?: {};
              describe?: {};
              distinct?: {};
              drop?: {};
              expression?: {
                  aggregate?: {
                      preVisitor?: (
                          op:
                              | Algebra.AggregateExpression
                              | Algebra.GroupConcatExpression
                              | Algebra.BoundAggregate,
                      ) => VisitContext;
                      visitor?: (
                          op:
                              | Algebra.AggregateExpression
                              | Algebra.GroupConcatExpression
                              | Algebra.BoundAggregate,
                      ) => void;
                  };
                  existence?: {
                      preVisitor?: (op: Algebra.ExistenceExpression) => VisitContext;
                      visitor?: (op: Algebra.ExistenceExpression) => void;
                  };
                  named?: {
                      preVisitor?: (op: Algebra.NamedExpression) => VisitContext;
                      visitor?: (op: Algebra.NamedExpression) => void;
                  };
                  operator?: {
                      preVisitor?: (op: Algebra.OperatorExpression) => VisitContext;
                      visitor?: (op: Algebra.OperatorExpression) => void;
                  };
                  term?: {
                      preVisitor?: (op: Algebra.TermExpression) => VisitContext;
                      visitor?: (op: Algebra.TermExpression) => void;
                  };
                  wildcard?: {
                      preVisitor?: (op: Algebra.WildcardExpression) => VisitContext;
                      visitor?: (op: Algebra.WildcardExpression) => void;
                  };
              };
              extend?: {};
              filter?: {};
              from?: {};
              graph?: {};
              group?: {};
              inv?: {};
              join?: {};
              leftjoin?: {};
              link?: {};
              load?: {};
              minus?: {};
              move?: {};
              nop?: {};
              nps?: {};
              OneOrMorePath?: {};
              orderby?: {};
              path?: {};
              pattern?: {};
              project?: {};
              reduced?: {};
              seq?: {};
              service?: {};
              slice?: {};
              union?: {};
              values?: {};
              ZeroOrMorePath?: {};
              ZeroOrOnePath?: {};
          }

          Same as nodeCallBacks but using an additional level of indirection to indicate the subType.

        Returns void

    the object from which we will start visiting, potentially visiting its descendants along the way.

    a dictionary mapping the various operation types to objects optionally containing preVisitor and visitor. The preVisitor allows you to provide VisitContext for the current object, altering how it will be visited. The visitor allows you to visit the object from deepest to the outermost object. This is useful if you for example want to manipulate the objects you visit during your visits, similar to mapOperation.

    Same as nodeCallBacks but using an additional level of indirection to indicate the subType.

    Settings

    Member Visibility