Function inScopeVariables

Parameters

• op: Algebra.BaseOperation

  Input algebra tree.

• Optionalvisitor: (
      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;
          };
      },
  ) => void

  the visitor to be used to traverse the various nodes. Allows you to provide a visitor with different default preVisitor cotexts.