1 module graphql.visitor; 2 3 import graphql.ast; 4 import graphql.tokenmodule; 5 6 class Visitor : ConstVisitor { 7 @safe : 8 9 alias accept = ConstVisitor.accept; 10 11 alias enter = ConstVisitor.enter; 12 13 alias exit = ConstVisitor.exit; 14 15 16 void enter(Document obj) {} 17 void exit(Document obj) {} 18 19 void accept(Document obj) { 20 enter(obj); 21 final switch(obj.ruleSelection) { 22 case DocumentEnum.Defi: 23 obj.defs.visit(this); 24 break; 25 } 26 exit(obj); 27 } 28 29 void enter(Definitions obj) {} 30 void exit(Definitions obj) {} 31 32 void accept(Definitions obj) { 33 enter(obj); 34 final switch(obj.ruleSelection) { 35 case DefinitionsEnum.Def: 36 obj.def.visit(this); 37 break; 38 case DefinitionsEnum.Defs: 39 obj.def.visit(this); 40 obj.follow.visit(this); 41 break; 42 } 43 exit(obj); 44 } 45 46 void enter(Definition obj) {} 47 void exit(Definition obj) {} 48 49 void accept(Definition obj) { 50 enter(obj); 51 final switch(obj.ruleSelection) { 52 case DefinitionEnum.O: 53 obj.op.visit(this); 54 break; 55 case DefinitionEnum.F: 56 obj.frag.visit(this); 57 break; 58 case DefinitionEnum.T: 59 obj.type.visit(this); 60 break; 61 } 62 exit(obj); 63 } 64 65 void enter(OperationDefinition obj) {} 66 void exit(OperationDefinition obj) {} 67 68 void accept(OperationDefinition obj) { 69 enter(obj); 70 final switch(obj.ruleSelection) { 71 case OperationDefinitionEnum.SelSet: 72 obj.ss.visit(this); 73 break; 74 case OperationDefinitionEnum.OT_N_VD: 75 obj.ot.visit(this); 76 obj.name.visit(this); 77 obj.vd.visit(this); 78 obj.d.visit(this); 79 obj.ss.visit(this); 80 break; 81 case OperationDefinitionEnum.OT_N_V: 82 obj.ot.visit(this); 83 obj.name.visit(this); 84 obj.vd.visit(this); 85 obj.ss.visit(this); 86 break; 87 case OperationDefinitionEnum.OT_N_D: 88 obj.ot.visit(this); 89 obj.name.visit(this); 90 obj.d.visit(this); 91 obj.ss.visit(this); 92 break; 93 case OperationDefinitionEnum.OT_N: 94 obj.ot.visit(this); 95 obj.name.visit(this); 96 obj.ss.visit(this); 97 break; 98 case OperationDefinitionEnum.OT_VD: 99 obj.ot.visit(this); 100 obj.vd.visit(this); 101 obj.d.visit(this); 102 obj.ss.visit(this); 103 break; 104 case OperationDefinitionEnum.OT_V: 105 obj.ot.visit(this); 106 obj.vd.visit(this); 107 obj.ss.visit(this); 108 break; 109 case OperationDefinitionEnum.OT_D: 110 obj.ot.visit(this); 111 obj.d.visit(this); 112 obj.ss.visit(this); 113 break; 114 case OperationDefinitionEnum.OT: 115 obj.ot.visit(this); 116 obj.ss.visit(this); 117 break; 118 } 119 exit(obj); 120 } 121 122 void enter(SelectionSet obj) {} 123 void exit(SelectionSet obj) {} 124 125 void accept(SelectionSet obj) { 126 enter(obj); 127 final switch(obj.ruleSelection) { 128 case SelectionSetEnum.SS: 129 obj.sel.visit(this); 130 break; 131 } 132 exit(obj); 133 } 134 135 void enter(OperationType obj) {} 136 void exit(OperationType obj) {} 137 138 void accept(OperationType obj) { 139 enter(obj); 140 final switch(obj.ruleSelection) { 141 case OperationTypeEnum.Query: 142 obj.tok.visit(this); 143 break; 144 case OperationTypeEnum.Mutation: 145 obj.tok.visit(this); 146 break; 147 case OperationTypeEnum.Sub: 148 obj.tok.visit(this); 149 break; 150 } 151 exit(obj); 152 } 153 154 void enter(Selections obj) {} 155 void exit(Selections obj) {} 156 157 void accept(Selections obj) { 158 enter(obj); 159 final switch(obj.ruleSelection) { 160 case SelectionsEnum.Sel: 161 obj.sel.visit(this); 162 break; 163 case SelectionsEnum.Sels: 164 obj.sel.visit(this); 165 obj.follow.visit(this); 166 break; 167 case SelectionsEnum.Selsc: 168 obj.sel.visit(this); 169 obj.follow.visit(this); 170 break; 171 } 172 exit(obj); 173 } 174 175 void enter(Selection obj) {} 176 void exit(Selection obj) {} 177 178 void accept(Selection obj) { 179 enter(obj); 180 final switch(obj.ruleSelection) { 181 case SelectionEnum.Field: 182 obj.field.visit(this); 183 break; 184 case SelectionEnum.Spread: 185 obj.frag.visit(this); 186 break; 187 case SelectionEnum.IFrag: 188 obj.ifrag.visit(this); 189 break; 190 } 191 exit(obj); 192 } 193 194 void enter(FragmentSpread obj) {} 195 void exit(FragmentSpread obj) {} 196 197 void accept(FragmentSpread obj) { 198 enter(obj); 199 final switch(obj.ruleSelection) { 200 case FragmentSpreadEnum.FD: 201 obj.name.visit(this); 202 obj.dirs.visit(this); 203 break; 204 case FragmentSpreadEnum.F: 205 obj.name.visit(this); 206 break; 207 } 208 exit(obj); 209 } 210 211 void enter(InlineFragment obj) {} 212 void exit(InlineFragment obj) {} 213 214 void accept(InlineFragment obj) { 215 enter(obj); 216 final switch(obj.ruleSelection) { 217 case InlineFragmentEnum.TDS: 218 obj.tc.visit(this); 219 obj.dirs.visit(this); 220 obj.ss.visit(this); 221 break; 222 case InlineFragmentEnum.TS: 223 obj.tc.visit(this); 224 obj.ss.visit(this); 225 break; 226 case InlineFragmentEnum.DS: 227 obj.dirs.visit(this); 228 obj.ss.visit(this); 229 break; 230 case InlineFragmentEnum.S: 231 obj.ss.visit(this); 232 break; 233 } 234 exit(obj); 235 } 236 237 void enter(Field obj) {} 238 void exit(Field obj) {} 239 240 void accept(Field obj) { 241 enter(obj); 242 final switch(obj.ruleSelection) { 243 case FieldEnum.FADS: 244 obj.name.visit(this); 245 obj.args.visit(this); 246 obj.dirs.visit(this); 247 obj.ss.visit(this); 248 break; 249 case FieldEnum.FAS: 250 obj.name.visit(this); 251 obj.args.visit(this); 252 obj.ss.visit(this); 253 break; 254 case FieldEnum.FAD: 255 obj.name.visit(this); 256 obj.args.visit(this); 257 obj.dirs.visit(this); 258 break; 259 case FieldEnum.FDS: 260 obj.name.visit(this); 261 obj.dirs.visit(this); 262 obj.ss.visit(this); 263 break; 264 case FieldEnum.FS: 265 obj.name.visit(this); 266 obj.ss.visit(this); 267 break; 268 case FieldEnum.FD: 269 obj.name.visit(this); 270 obj.dirs.visit(this); 271 break; 272 case FieldEnum.FA: 273 obj.name.visit(this); 274 obj.args.visit(this); 275 break; 276 case FieldEnum.F: 277 obj.name.visit(this); 278 break; 279 } 280 exit(obj); 281 } 282 283 void enter(FieldName obj) {} 284 void exit(FieldName obj) {} 285 286 void accept(FieldName obj) { 287 enter(obj); 288 final switch(obj.ruleSelection) { 289 case FieldNameEnum.A: 290 obj.name.visit(this); 291 obj.aka.visit(this); 292 break; 293 case FieldNameEnum.N: 294 obj.name.visit(this); 295 break; 296 } 297 exit(obj); 298 } 299 300 void enter(Arguments obj) {} 301 void exit(Arguments obj) {} 302 303 void accept(Arguments obj) { 304 enter(obj); 305 final switch(obj.ruleSelection) { 306 case ArgumentsEnum.List: 307 obj.arg.visit(this); 308 break; 309 case ArgumentsEnum.Empty: 310 break; 311 } 312 exit(obj); 313 } 314 315 void enter(ArgumentList obj) {} 316 void exit(ArgumentList obj) {} 317 318 void accept(ArgumentList obj) { 319 enter(obj); 320 final switch(obj.ruleSelection) { 321 case ArgumentListEnum.A: 322 obj.arg.visit(this); 323 break; 324 case ArgumentListEnum.ACS: 325 obj.arg.visit(this); 326 obj.follow.visit(this); 327 break; 328 case ArgumentListEnum.AS: 329 obj.arg.visit(this); 330 obj.follow.visit(this); 331 break; 332 } 333 exit(obj); 334 } 335 336 void enter(Argument obj) {} 337 void exit(Argument obj) {} 338 339 void accept(Argument obj) { 340 enter(obj); 341 final switch(obj.ruleSelection) { 342 case ArgumentEnum.Name: 343 obj.name.visit(this); 344 obj.vv.visit(this); 345 break; 346 } 347 exit(obj); 348 } 349 350 void enter(FragmentDefinition obj) {} 351 void exit(FragmentDefinition obj) {} 352 353 void accept(FragmentDefinition obj) { 354 enter(obj); 355 final switch(obj.ruleSelection) { 356 case FragmentDefinitionEnum.FTDS: 357 obj.name.visit(this); 358 obj.tc.visit(this); 359 obj.dirs.visit(this); 360 obj.ss.visit(this); 361 break; 362 case FragmentDefinitionEnum.FTS: 363 obj.name.visit(this); 364 obj.tc.visit(this); 365 obj.ss.visit(this); 366 break; 367 } 368 exit(obj); 369 } 370 371 void enter(Directives obj) {} 372 void exit(Directives obj) {} 373 374 void accept(Directives obj) { 375 enter(obj); 376 final switch(obj.ruleSelection) { 377 case DirectivesEnum.Dir: 378 obj.dir.visit(this); 379 break; 380 case DirectivesEnum.Dirs: 381 obj.dir.visit(this); 382 obj.follow.visit(this); 383 break; 384 } 385 exit(obj); 386 } 387 388 void enter(Directive obj) {} 389 void exit(Directive obj) {} 390 391 void accept(Directive obj) { 392 enter(obj); 393 final switch(obj.ruleSelection) { 394 case DirectiveEnum.NArg: 395 obj.name.visit(this); 396 obj.arg.visit(this); 397 break; 398 case DirectiveEnum.N: 399 obj.name.visit(this); 400 break; 401 } 402 exit(obj); 403 } 404 405 void enter(VariableDefinitions obj) {} 406 void exit(VariableDefinitions obj) {} 407 408 void accept(VariableDefinitions obj) { 409 enter(obj); 410 final switch(obj.ruleSelection) { 411 case VariableDefinitionsEnum.Empty: 412 break; 413 case VariableDefinitionsEnum.Vars: 414 obj.vars.visit(this); 415 break; 416 } 417 exit(obj); 418 } 419 420 void enter(VariableDefinitionList obj) {} 421 void exit(VariableDefinitionList obj) {} 422 423 void accept(VariableDefinitionList obj) { 424 enter(obj); 425 final switch(obj.ruleSelection) { 426 case VariableDefinitionListEnum.V: 427 obj.var.visit(this); 428 break; 429 case VariableDefinitionListEnum.VCF: 430 obj.var.visit(this); 431 obj.follow.visit(this); 432 break; 433 case VariableDefinitionListEnum.VF: 434 obj.var.visit(this); 435 obj.follow.visit(this); 436 break; 437 } 438 exit(obj); 439 } 440 441 void enter(VariableDefinition obj) {} 442 void exit(VariableDefinition obj) {} 443 444 void accept(VariableDefinition obj) { 445 enter(obj); 446 final switch(obj.ruleSelection) { 447 case VariableDefinitionEnum.VarD: 448 obj.var.visit(this); 449 obj.type.visit(this); 450 obj.dvalue.visit(this); 451 break; 452 case VariableDefinitionEnum.Var: 453 obj.var.visit(this); 454 obj.type.visit(this); 455 break; 456 } 457 exit(obj); 458 } 459 460 void enter(Variable obj) {} 461 void exit(Variable obj) {} 462 463 void accept(Variable obj) { 464 enter(obj); 465 final switch(obj.ruleSelection) { 466 case VariableEnum.Var: 467 obj.name.visit(this); 468 break; 469 } 470 exit(obj); 471 } 472 473 void enter(DefaultValue obj) {} 474 void exit(DefaultValue obj) {} 475 476 void accept(DefaultValue obj) { 477 enter(obj); 478 final switch(obj.ruleSelection) { 479 case DefaultValueEnum.DV: 480 obj.value.visit(this); 481 break; 482 } 483 exit(obj); 484 } 485 486 void enter(ValueOrVariable obj) {} 487 void exit(ValueOrVariable obj) {} 488 489 void accept(ValueOrVariable obj) { 490 enter(obj); 491 final switch(obj.ruleSelection) { 492 case ValueOrVariableEnum.Val: 493 obj.val.visit(this); 494 break; 495 case ValueOrVariableEnum.Var: 496 obj.var.visit(this); 497 break; 498 } 499 exit(obj); 500 } 501 502 void enter(Value obj) {} 503 void exit(Value obj) {} 504 505 void accept(Value obj) { 506 enter(obj); 507 final switch(obj.ruleSelection) { 508 case ValueEnum.STR: 509 obj.tok.visit(this); 510 break; 511 case ValueEnum.INT: 512 obj.tok.visit(this); 513 break; 514 case ValueEnum.FLOAT: 515 obj.tok.visit(this); 516 break; 517 case ValueEnum.T: 518 obj.tok.visit(this); 519 break; 520 case ValueEnum.F: 521 obj.tok.visit(this); 522 break; 523 case ValueEnum.ARR: 524 obj.arr.visit(this); 525 break; 526 case ValueEnum.O: 527 obj.obj.visit(this); 528 break; 529 case ValueEnum.E: 530 obj.tok.visit(this); 531 break; 532 case ValueEnum.N: 533 obj.tok.visit(this); 534 break; 535 } 536 exit(obj); 537 } 538 539 void enter(Type obj) {} 540 void exit(Type obj) {} 541 542 void accept(Type obj) { 543 enter(obj); 544 final switch(obj.ruleSelection) { 545 case TypeEnum.TN: 546 obj.tname.visit(this); 547 break; 548 case TypeEnum.LN: 549 obj.list.visit(this); 550 break; 551 case TypeEnum.T: 552 obj.tname.visit(this); 553 break; 554 case TypeEnum.L: 555 obj.list.visit(this); 556 break; 557 } 558 exit(obj); 559 } 560 561 void enter(ListType obj) {} 562 void exit(ListType obj) {} 563 564 void accept(ListType obj) { 565 enter(obj); 566 final switch(obj.ruleSelection) { 567 case ListTypeEnum.T: 568 obj.type.visit(this); 569 break; 570 } 571 exit(obj); 572 } 573 574 void enter(Values obj) {} 575 void exit(Values obj) {} 576 577 void accept(Values obj) { 578 enter(obj); 579 final switch(obj.ruleSelection) { 580 case ValuesEnum.Val: 581 obj.val.visit(this); 582 break; 583 case ValuesEnum.Vals: 584 obj.val.visit(this); 585 obj.follow.visit(this); 586 break; 587 } 588 exit(obj); 589 } 590 591 void enter(Array obj) {} 592 void exit(Array obj) {} 593 594 void accept(Array obj) { 595 enter(obj); 596 final switch(obj.ruleSelection) { 597 case ArrayEnum.Empty: 598 break; 599 case ArrayEnum.Value: 600 obj.vals.visit(this); 601 break; 602 } 603 exit(obj); 604 } 605 606 void enter(ObjectValues obj) {} 607 void exit(ObjectValues obj) {} 608 609 void accept(ObjectValues obj) { 610 enter(obj); 611 final switch(obj.ruleSelection) { 612 case ObjectValuesEnum.V: 613 obj.name.visit(this); 614 obj.val.visit(this); 615 break; 616 case ObjectValuesEnum.Vsc: 617 obj.name.visit(this); 618 obj.val.visit(this); 619 obj.follow.visit(this); 620 break; 621 case ObjectValuesEnum.Vs: 622 obj.name.visit(this); 623 obj.val.visit(this); 624 obj.follow.visit(this); 625 break; 626 } 627 exit(obj); 628 } 629 630 void enter(ObjectType obj) {} 631 void exit(ObjectType obj) {} 632 633 void accept(ObjectType obj) { 634 enter(obj); 635 final switch(obj.ruleSelection) { 636 case ObjectTypeEnum.Var: 637 obj.vals.visit(this); 638 break; 639 } 640 exit(obj); 641 } 642 643 void enter(TypeSystemDefinition obj) {} 644 void exit(TypeSystemDefinition obj) {} 645 646 void accept(TypeSystemDefinition obj) { 647 enter(obj); 648 final switch(obj.ruleSelection) { 649 case TypeSystemDefinitionEnum.S: 650 obj.sch.visit(this); 651 break; 652 case TypeSystemDefinitionEnum.T: 653 obj.td.visit(this); 654 break; 655 case TypeSystemDefinitionEnum.TE: 656 obj.ted.visit(this); 657 break; 658 case TypeSystemDefinitionEnum.D: 659 obj.dd.visit(this); 660 break; 661 case TypeSystemDefinitionEnum.DS: 662 obj.des.visit(this); 663 obj.sch.visit(this); 664 break; 665 case TypeSystemDefinitionEnum.DT: 666 obj.des.visit(this); 667 obj.td.visit(this); 668 break; 669 case TypeSystemDefinitionEnum.DTE: 670 obj.des.visit(this); 671 obj.ted.visit(this); 672 break; 673 case TypeSystemDefinitionEnum.DD: 674 obj.des.visit(this); 675 obj.dd.visit(this); 676 break; 677 } 678 exit(obj); 679 } 680 681 void enter(TypeDefinition obj) {} 682 void exit(TypeDefinition obj) {} 683 684 void accept(TypeDefinition obj) { 685 enter(obj); 686 final switch(obj.ruleSelection) { 687 case TypeDefinitionEnum.S: 688 obj.std.visit(this); 689 break; 690 case TypeDefinitionEnum.O: 691 obj.otd.visit(this); 692 break; 693 case TypeDefinitionEnum.I: 694 obj.itd.visit(this); 695 break; 696 case TypeDefinitionEnum.U: 697 obj.utd.visit(this); 698 break; 699 case TypeDefinitionEnum.E: 700 obj.etd.visit(this); 701 break; 702 case TypeDefinitionEnum.IO: 703 obj.iod.visit(this); 704 break; 705 } 706 exit(obj); 707 } 708 709 void enter(SchemaDefinition obj) {} 710 void exit(SchemaDefinition obj) {} 711 712 void accept(SchemaDefinition obj) { 713 enter(obj); 714 final switch(obj.ruleSelection) { 715 case SchemaDefinitionEnum.DO: 716 obj.dir.visit(this); 717 obj.otds.visit(this); 718 break; 719 case SchemaDefinitionEnum.O: 720 obj.otds.visit(this); 721 break; 722 } 723 exit(obj); 724 } 725 726 void enter(OperationTypeDefinitions obj) {} 727 void exit(OperationTypeDefinitions obj) {} 728 729 void accept(OperationTypeDefinitions obj) { 730 enter(obj); 731 final switch(obj.ruleSelection) { 732 case OperationTypeDefinitionsEnum.O: 733 obj.otd.visit(this); 734 break; 735 case OperationTypeDefinitionsEnum.OCS: 736 obj.otd.visit(this); 737 obj.follow.visit(this); 738 break; 739 case OperationTypeDefinitionsEnum.OS: 740 obj.otd.visit(this); 741 obj.follow.visit(this); 742 break; 743 } 744 exit(obj); 745 } 746 747 void enter(OperationTypeDefinition obj) {} 748 void exit(OperationTypeDefinition obj) {} 749 750 void accept(OperationTypeDefinition obj) { 751 enter(obj); 752 final switch(obj.ruleSelection) { 753 case OperationTypeDefinitionEnum.O: 754 obj.ot.visit(this); 755 obj.nt.visit(this); 756 break; 757 } 758 exit(obj); 759 } 760 761 void enter(ScalarTypeDefinition obj) {} 762 void exit(ScalarTypeDefinition obj) {} 763 764 void accept(ScalarTypeDefinition obj) { 765 enter(obj); 766 final switch(obj.ruleSelection) { 767 case ScalarTypeDefinitionEnum.D: 768 obj.name.visit(this); 769 obj.dir.visit(this); 770 break; 771 case ScalarTypeDefinitionEnum.S: 772 obj.name.visit(this); 773 break; 774 } 775 exit(obj); 776 } 777 778 void enter(ObjectTypeDefinition obj) {} 779 void exit(ObjectTypeDefinition obj) {} 780 781 void accept(ObjectTypeDefinition obj) { 782 enter(obj); 783 final switch(obj.ruleSelection) { 784 case ObjectTypeDefinitionEnum.ID: 785 obj.name.visit(this); 786 obj.ii.visit(this); 787 obj.dir.visit(this); 788 obj.fds.visit(this); 789 break; 790 case ObjectTypeDefinitionEnum.I: 791 obj.name.visit(this); 792 obj.ii.visit(this); 793 obj.fds.visit(this); 794 break; 795 case ObjectTypeDefinitionEnum.D: 796 obj.name.visit(this); 797 obj.dir.visit(this); 798 obj.fds.visit(this); 799 break; 800 case ObjectTypeDefinitionEnum.F: 801 obj.name.visit(this); 802 obj.fds.visit(this); 803 break; 804 } 805 exit(obj); 806 } 807 808 void enter(FieldDefinitions obj) {} 809 void exit(FieldDefinitions obj) {} 810 811 void accept(FieldDefinitions obj) { 812 enter(obj); 813 final switch(obj.ruleSelection) { 814 case FieldDefinitionsEnum.F: 815 obj.fd.visit(this); 816 break; 817 case FieldDefinitionsEnum.FC: 818 obj.fd.visit(this); 819 obj.follow.visit(this); 820 break; 821 case FieldDefinitionsEnum.FNC: 822 obj.fd.visit(this); 823 obj.follow.visit(this); 824 break; 825 } 826 exit(obj); 827 } 828 829 void enter(FieldDefinition obj) {} 830 void exit(FieldDefinition obj) {} 831 832 void accept(FieldDefinition obj) { 833 enter(obj); 834 final switch(obj.ruleSelection) { 835 case FieldDefinitionEnum.AD: 836 obj.name.visit(this); 837 obj.arg.visit(this); 838 obj.typ.visit(this); 839 obj.dir.visit(this); 840 break; 841 case FieldDefinitionEnum.A: 842 obj.name.visit(this); 843 obj.arg.visit(this); 844 obj.typ.visit(this); 845 break; 846 case FieldDefinitionEnum.D: 847 obj.name.visit(this); 848 obj.typ.visit(this); 849 obj.dir.visit(this); 850 break; 851 case FieldDefinitionEnum.T: 852 obj.name.visit(this); 853 obj.typ.visit(this); 854 break; 855 case FieldDefinitionEnum.DAD: 856 obj.des.visit(this); 857 obj.name.visit(this); 858 obj.arg.visit(this); 859 obj.typ.visit(this); 860 obj.dir.visit(this); 861 break; 862 case FieldDefinitionEnum.DA: 863 obj.des.visit(this); 864 obj.name.visit(this); 865 obj.arg.visit(this); 866 obj.typ.visit(this); 867 break; 868 case FieldDefinitionEnum.DD: 869 obj.des.visit(this); 870 obj.name.visit(this); 871 obj.typ.visit(this); 872 obj.dir.visit(this); 873 break; 874 case FieldDefinitionEnum.DT: 875 obj.des.visit(this); 876 obj.name.visit(this); 877 obj.typ.visit(this); 878 break; 879 } 880 exit(obj); 881 } 882 883 void enter(ImplementsInterfaces obj) {} 884 void exit(ImplementsInterfaces obj) {} 885 886 void accept(ImplementsInterfaces obj) { 887 enter(obj); 888 final switch(obj.ruleSelection) { 889 case ImplementsInterfacesEnum.N: 890 obj.nts.visit(this); 891 break; 892 } 893 exit(obj); 894 } 895 896 void enter(NamedTypes obj) {} 897 void exit(NamedTypes obj) {} 898 899 void accept(NamedTypes obj) { 900 enter(obj); 901 final switch(obj.ruleSelection) { 902 case NamedTypesEnum.N: 903 obj.name.visit(this); 904 break; 905 case NamedTypesEnum.NCS: 906 obj.name.visit(this); 907 obj.follow.visit(this); 908 break; 909 case NamedTypesEnum.NS: 910 obj.name.visit(this); 911 obj.follow.visit(this); 912 break; 913 } 914 exit(obj); 915 } 916 917 void enter(ArgumentsDefinition obj) {} 918 void exit(ArgumentsDefinition obj) {} 919 920 void accept(ArgumentsDefinition obj) { 921 enter(obj); 922 final switch(obj.ruleSelection) { 923 case ArgumentsDefinitionEnum.A: 924 break; 925 case ArgumentsDefinitionEnum.DA: 926 obj.des.visit(this); 927 break; 928 } 929 exit(obj); 930 } 931 932 void enter(InputValueDefinitions obj) {} 933 void exit(InputValueDefinitions obj) {} 934 935 void accept(InputValueDefinitions obj) { 936 enter(obj); 937 final switch(obj.ruleSelection) { 938 case InputValueDefinitionsEnum.I: 939 obj.iv.visit(this); 940 break; 941 case InputValueDefinitionsEnum.ICF: 942 obj.iv.visit(this); 943 obj.follow.visit(this); 944 break; 945 case InputValueDefinitionsEnum.IF: 946 obj.iv.visit(this); 947 obj.follow.visit(this); 948 break; 949 } 950 exit(obj); 951 } 952 953 void enter(InputValueDefinition obj) {} 954 void exit(InputValueDefinition obj) {} 955 956 void accept(InputValueDefinition obj) { 957 enter(obj); 958 final switch(obj.ruleSelection) { 959 case InputValueDefinitionEnum.TVD: 960 obj.name.visit(this); 961 obj.type.visit(this); 962 obj.df.visit(this); 963 obj.dirs.visit(this); 964 break; 965 case InputValueDefinitionEnum.TD: 966 obj.name.visit(this); 967 obj.type.visit(this); 968 obj.dirs.visit(this); 969 break; 970 case InputValueDefinitionEnum.TV: 971 obj.name.visit(this); 972 obj.type.visit(this); 973 obj.df.visit(this); 974 break; 975 case InputValueDefinitionEnum.T: 976 obj.name.visit(this); 977 obj.type.visit(this); 978 break; 979 } 980 exit(obj); 981 } 982 983 void enter(InterfaceTypeDefinition obj) {} 984 void exit(InterfaceTypeDefinition obj) {} 985 986 void accept(InterfaceTypeDefinition obj) { 987 enter(obj); 988 final switch(obj.ruleSelection) { 989 case InterfaceTypeDefinitionEnum.NDF: 990 obj.name.visit(this); 991 obj.dirs.visit(this); 992 obj.fds.visit(this); 993 break; 994 case InterfaceTypeDefinitionEnum.NF: 995 obj.name.visit(this); 996 obj.fds.visit(this); 997 break; 998 } 999 exit(obj); 1000 } 1001 1002 void enter(UnionTypeDefinition obj) {} 1003 void exit(UnionTypeDefinition obj) {} 1004 1005 void accept(UnionTypeDefinition obj) { 1006 enter(obj); 1007 final switch(obj.ruleSelection) { 1008 case UnionTypeDefinitionEnum.NDU: 1009 obj.name.visit(this); 1010 obj.dirs.visit(this); 1011 obj.um.visit(this); 1012 break; 1013 case UnionTypeDefinitionEnum.NU: 1014 obj.name.visit(this); 1015 obj.um.visit(this); 1016 break; 1017 } 1018 exit(obj); 1019 } 1020 1021 void enter(UnionMembers obj) {} 1022 void exit(UnionMembers obj) {} 1023 1024 void accept(UnionMembers obj) { 1025 enter(obj); 1026 final switch(obj.ruleSelection) { 1027 case UnionMembersEnum.S: 1028 obj.name.visit(this); 1029 break; 1030 case UnionMembersEnum.SPF: 1031 obj.name.visit(this); 1032 obj.follow.visit(this); 1033 break; 1034 case UnionMembersEnum.SF: 1035 obj.name.visit(this); 1036 obj.follow.visit(this); 1037 break; 1038 } 1039 exit(obj); 1040 } 1041 1042 void enter(EnumTypeDefinition obj) {} 1043 void exit(EnumTypeDefinition obj) {} 1044 1045 void accept(EnumTypeDefinition obj) { 1046 enter(obj); 1047 final switch(obj.ruleSelection) { 1048 case EnumTypeDefinitionEnum.NDE: 1049 obj.name.visit(this); 1050 obj.dir.visit(this); 1051 obj.evds.visit(this); 1052 break; 1053 case EnumTypeDefinitionEnum.NE: 1054 obj.name.visit(this); 1055 obj.evds.visit(this); 1056 break; 1057 } 1058 exit(obj); 1059 } 1060 1061 void enter(EnumValueDefinitions obj) {} 1062 void exit(EnumValueDefinitions obj) {} 1063 1064 void accept(EnumValueDefinitions obj) { 1065 enter(obj); 1066 final switch(obj.ruleSelection) { 1067 case EnumValueDefinitionsEnum.D: 1068 obj.evd.visit(this); 1069 break; 1070 case EnumValueDefinitionsEnum.DCE: 1071 obj.evd.visit(this); 1072 obj.follow.visit(this); 1073 break; 1074 case EnumValueDefinitionsEnum.DE: 1075 obj.evd.visit(this); 1076 obj.follow.visit(this); 1077 break; 1078 } 1079 exit(obj); 1080 } 1081 1082 void enter(EnumValueDefinition obj) {} 1083 void exit(EnumValueDefinition obj) {} 1084 1085 void accept(EnumValueDefinition obj) { 1086 enter(obj); 1087 final switch(obj.ruleSelection) { 1088 case EnumValueDefinitionEnum.ED: 1089 obj.name.visit(this); 1090 obj.dirs.visit(this); 1091 break; 1092 case EnumValueDefinitionEnum.E: 1093 obj.name.visit(this); 1094 break; 1095 } 1096 exit(obj); 1097 } 1098 1099 void enter(InputTypeDefinition obj) {} 1100 void exit(InputTypeDefinition obj) {} 1101 1102 void accept(InputTypeDefinition obj) { 1103 enter(obj); 1104 final switch(obj.ruleSelection) { 1105 case InputTypeDefinitionEnum.NDE: 1106 obj.name.visit(this); 1107 obj.dir.visit(this); 1108 obj.ivds.visit(this); 1109 break; 1110 case InputTypeDefinitionEnum.NE: 1111 obj.name.visit(this); 1112 obj.ivds.visit(this); 1113 break; 1114 } 1115 exit(obj); 1116 } 1117 1118 void enter(TypeExtensionDefinition obj) {} 1119 void exit(TypeExtensionDefinition obj) {} 1120 1121 void accept(TypeExtensionDefinition obj) { 1122 enter(obj); 1123 final switch(obj.ruleSelection) { 1124 case TypeExtensionDefinitionEnum.O: 1125 obj.otd.visit(this); 1126 break; 1127 } 1128 exit(obj); 1129 } 1130 1131 void enter(DirectiveDefinition obj) {} 1132 void exit(DirectiveDefinition obj) {} 1133 1134 void accept(DirectiveDefinition obj) { 1135 enter(obj); 1136 final switch(obj.ruleSelection) { 1137 case DirectiveDefinitionEnum.AD: 1138 obj.name.visit(this); 1139 obj.ad.visit(this); 1140 obj.dl.visit(this); 1141 break; 1142 case DirectiveDefinitionEnum.D: 1143 obj.name.visit(this); 1144 obj.dl.visit(this); 1145 break; 1146 } 1147 exit(obj); 1148 } 1149 1150 void enter(DirectiveLocations obj) {} 1151 void exit(DirectiveLocations obj) {} 1152 1153 void accept(DirectiveLocations obj) { 1154 enter(obj); 1155 final switch(obj.ruleSelection) { 1156 case DirectiveLocationsEnum.N: 1157 obj.name.visit(this); 1158 break; 1159 case DirectiveLocationsEnum.NPF: 1160 obj.name.visit(this); 1161 obj.follow.visit(this); 1162 break; 1163 case DirectiveLocationsEnum.NF: 1164 obj.name.visit(this); 1165 obj.follow.visit(this); 1166 break; 1167 } 1168 exit(obj); 1169 } 1170 1171 void enter(InputObjectTypeDefinition obj) {} 1172 void exit(InputObjectTypeDefinition obj) {} 1173 1174 void accept(InputObjectTypeDefinition obj) { 1175 enter(obj); 1176 final switch(obj.ruleSelection) { 1177 case InputObjectTypeDefinitionEnum.NDI: 1178 obj.name.visit(this); 1179 obj.dirs.visit(this); 1180 break; 1181 case InputObjectTypeDefinitionEnum.NI: 1182 obj.name.visit(this); 1183 break; 1184 } 1185 exit(obj); 1186 } 1187 1188 void enter(Description obj) {} 1189 void exit(Description obj) {} 1190 1191 void accept(Description obj) { 1192 enter(obj); 1193 final switch(obj.ruleSelection) { 1194 case DescriptionEnum.S: 1195 obj.tok.visit(this); 1196 break; 1197 } 1198 exit(obj); 1199 } 1200 } 1201 1202 class ConstVisitor { 1203 @safe : 1204 1205 1206 void enter(const(Document) obj) {} 1207 void exit(const(Document) obj) {} 1208 1209 void accept(const(Document) obj) { 1210 enter(obj); 1211 final switch(obj.ruleSelection) { 1212 case DocumentEnum.Defi: 1213 obj.defs.visit(this); 1214 break; 1215 } 1216 exit(obj); 1217 } 1218 1219 void enter(const(Definitions) obj) {} 1220 void exit(const(Definitions) obj) {} 1221 1222 void accept(const(Definitions) obj) { 1223 enter(obj); 1224 final switch(obj.ruleSelection) { 1225 case DefinitionsEnum.Def: 1226 obj.def.visit(this); 1227 break; 1228 case DefinitionsEnum.Defs: 1229 obj.def.visit(this); 1230 obj.follow.visit(this); 1231 break; 1232 } 1233 exit(obj); 1234 } 1235 1236 void enter(const(Definition) obj) {} 1237 void exit(const(Definition) obj) {} 1238 1239 void accept(const(Definition) obj) { 1240 enter(obj); 1241 final switch(obj.ruleSelection) { 1242 case DefinitionEnum.O: 1243 obj.op.visit(this); 1244 break; 1245 case DefinitionEnum.F: 1246 obj.frag.visit(this); 1247 break; 1248 case DefinitionEnum.T: 1249 obj.type.visit(this); 1250 break; 1251 } 1252 exit(obj); 1253 } 1254 1255 void enter(const(OperationDefinition) obj) {} 1256 void exit(const(OperationDefinition) obj) {} 1257 1258 void accept(const(OperationDefinition) obj) { 1259 enter(obj); 1260 final switch(obj.ruleSelection) { 1261 case OperationDefinitionEnum.SelSet: 1262 obj.ss.visit(this); 1263 break; 1264 case OperationDefinitionEnum.OT_N_VD: 1265 obj.ot.visit(this); 1266 obj.name.visit(this); 1267 obj.vd.visit(this); 1268 obj.d.visit(this); 1269 obj.ss.visit(this); 1270 break; 1271 case OperationDefinitionEnum.OT_N_V: 1272 obj.ot.visit(this); 1273 obj.name.visit(this); 1274 obj.vd.visit(this); 1275 obj.ss.visit(this); 1276 break; 1277 case OperationDefinitionEnum.OT_N_D: 1278 obj.ot.visit(this); 1279 obj.name.visit(this); 1280 obj.d.visit(this); 1281 obj.ss.visit(this); 1282 break; 1283 case OperationDefinitionEnum.OT_N: 1284 obj.ot.visit(this); 1285 obj.name.visit(this); 1286 obj.ss.visit(this); 1287 break; 1288 case OperationDefinitionEnum.OT_VD: 1289 obj.ot.visit(this); 1290 obj.vd.visit(this); 1291 obj.d.visit(this); 1292 obj.ss.visit(this); 1293 break; 1294 case OperationDefinitionEnum.OT_V: 1295 obj.ot.visit(this); 1296 obj.vd.visit(this); 1297 obj.ss.visit(this); 1298 break; 1299 case OperationDefinitionEnum.OT_D: 1300 obj.ot.visit(this); 1301 obj.d.visit(this); 1302 obj.ss.visit(this); 1303 break; 1304 case OperationDefinitionEnum.OT: 1305 obj.ot.visit(this); 1306 obj.ss.visit(this); 1307 break; 1308 } 1309 exit(obj); 1310 } 1311 1312 void enter(const(SelectionSet) obj) {} 1313 void exit(const(SelectionSet) obj) {} 1314 1315 void accept(const(SelectionSet) obj) { 1316 enter(obj); 1317 final switch(obj.ruleSelection) { 1318 case SelectionSetEnum.SS: 1319 obj.sel.visit(this); 1320 break; 1321 } 1322 exit(obj); 1323 } 1324 1325 void enter(const(OperationType) obj) {} 1326 void exit(const(OperationType) obj) {} 1327 1328 void accept(const(OperationType) obj) { 1329 enter(obj); 1330 final switch(obj.ruleSelection) { 1331 case OperationTypeEnum.Query: 1332 obj.tok.visit(this); 1333 break; 1334 case OperationTypeEnum.Mutation: 1335 obj.tok.visit(this); 1336 break; 1337 case OperationTypeEnum.Sub: 1338 obj.tok.visit(this); 1339 break; 1340 } 1341 exit(obj); 1342 } 1343 1344 void enter(const(Selections) obj) {} 1345 void exit(const(Selections) obj) {} 1346 1347 void accept(const(Selections) obj) { 1348 enter(obj); 1349 final switch(obj.ruleSelection) { 1350 case SelectionsEnum.Sel: 1351 obj.sel.visit(this); 1352 break; 1353 case SelectionsEnum.Sels: 1354 obj.sel.visit(this); 1355 obj.follow.visit(this); 1356 break; 1357 case SelectionsEnum.Selsc: 1358 obj.sel.visit(this); 1359 obj.follow.visit(this); 1360 break; 1361 } 1362 exit(obj); 1363 } 1364 1365 void enter(const(Selection) obj) {} 1366 void exit(const(Selection) obj) {} 1367 1368 void accept(const(Selection) obj) { 1369 enter(obj); 1370 final switch(obj.ruleSelection) { 1371 case SelectionEnum.Field: 1372 obj.field.visit(this); 1373 break; 1374 case SelectionEnum.Spread: 1375 obj.frag.visit(this); 1376 break; 1377 case SelectionEnum.IFrag: 1378 obj.ifrag.visit(this); 1379 break; 1380 } 1381 exit(obj); 1382 } 1383 1384 void enter(const(FragmentSpread) obj) {} 1385 void exit(const(FragmentSpread) obj) {} 1386 1387 void accept(const(FragmentSpread) obj) { 1388 enter(obj); 1389 final switch(obj.ruleSelection) { 1390 case FragmentSpreadEnum.FD: 1391 obj.name.visit(this); 1392 obj.dirs.visit(this); 1393 break; 1394 case FragmentSpreadEnum.F: 1395 obj.name.visit(this); 1396 break; 1397 } 1398 exit(obj); 1399 } 1400 1401 void enter(const(InlineFragment) obj) {} 1402 void exit(const(InlineFragment) obj) {} 1403 1404 void accept(const(InlineFragment) obj) { 1405 enter(obj); 1406 final switch(obj.ruleSelection) { 1407 case InlineFragmentEnum.TDS: 1408 obj.tc.visit(this); 1409 obj.dirs.visit(this); 1410 obj.ss.visit(this); 1411 break; 1412 case InlineFragmentEnum.TS: 1413 obj.tc.visit(this); 1414 obj.ss.visit(this); 1415 break; 1416 case InlineFragmentEnum.DS: 1417 obj.dirs.visit(this); 1418 obj.ss.visit(this); 1419 break; 1420 case InlineFragmentEnum.S: 1421 obj.ss.visit(this); 1422 break; 1423 } 1424 exit(obj); 1425 } 1426 1427 void enter(const(Field) obj) {} 1428 void exit(const(Field) obj) {} 1429 1430 void accept(const(Field) obj) { 1431 enter(obj); 1432 final switch(obj.ruleSelection) { 1433 case FieldEnum.FADS: 1434 obj.name.visit(this); 1435 obj.args.visit(this); 1436 obj.dirs.visit(this); 1437 obj.ss.visit(this); 1438 break; 1439 case FieldEnum.FAS: 1440 obj.name.visit(this); 1441 obj.args.visit(this); 1442 obj.ss.visit(this); 1443 break; 1444 case FieldEnum.FAD: 1445 obj.name.visit(this); 1446 obj.args.visit(this); 1447 obj.dirs.visit(this); 1448 break; 1449 case FieldEnum.FDS: 1450 obj.name.visit(this); 1451 obj.dirs.visit(this); 1452 obj.ss.visit(this); 1453 break; 1454 case FieldEnum.FS: 1455 obj.name.visit(this); 1456 obj.ss.visit(this); 1457 break; 1458 case FieldEnum.FD: 1459 obj.name.visit(this); 1460 obj.dirs.visit(this); 1461 break; 1462 case FieldEnum.FA: 1463 obj.name.visit(this); 1464 obj.args.visit(this); 1465 break; 1466 case FieldEnum.F: 1467 obj.name.visit(this); 1468 break; 1469 } 1470 exit(obj); 1471 } 1472 1473 void enter(const(FieldName) obj) {} 1474 void exit(const(FieldName) obj) {} 1475 1476 void accept(const(FieldName) obj) { 1477 enter(obj); 1478 final switch(obj.ruleSelection) { 1479 case FieldNameEnum.A: 1480 obj.name.visit(this); 1481 obj.aka.visit(this); 1482 break; 1483 case FieldNameEnum.N: 1484 obj.name.visit(this); 1485 break; 1486 } 1487 exit(obj); 1488 } 1489 1490 void enter(const(Arguments) obj) {} 1491 void exit(const(Arguments) obj) {} 1492 1493 void accept(const(Arguments) obj) { 1494 enter(obj); 1495 final switch(obj.ruleSelection) { 1496 case ArgumentsEnum.List: 1497 obj.arg.visit(this); 1498 break; 1499 case ArgumentsEnum.Empty: 1500 break; 1501 } 1502 exit(obj); 1503 } 1504 1505 void enter(const(ArgumentList) obj) {} 1506 void exit(const(ArgumentList) obj) {} 1507 1508 void accept(const(ArgumentList) obj) { 1509 enter(obj); 1510 final switch(obj.ruleSelection) { 1511 case ArgumentListEnum.A: 1512 obj.arg.visit(this); 1513 break; 1514 case ArgumentListEnum.ACS: 1515 obj.arg.visit(this); 1516 obj.follow.visit(this); 1517 break; 1518 case ArgumentListEnum.AS: 1519 obj.arg.visit(this); 1520 obj.follow.visit(this); 1521 break; 1522 } 1523 exit(obj); 1524 } 1525 1526 void enter(const(Argument) obj) {} 1527 void exit(const(Argument) obj) {} 1528 1529 void accept(const(Argument) obj) { 1530 enter(obj); 1531 final switch(obj.ruleSelection) { 1532 case ArgumentEnum.Name: 1533 obj.name.visit(this); 1534 obj.vv.visit(this); 1535 break; 1536 } 1537 exit(obj); 1538 } 1539 1540 void enter(const(FragmentDefinition) obj) {} 1541 void exit(const(FragmentDefinition) obj) {} 1542 1543 void accept(const(FragmentDefinition) obj) { 1544 enter(obj); 1545 final switch(obj.ruleSelection) { 1546 case FragmentDefinitionEnum.FTDS: 1547 obj.name.visit(this); 1548 obj.tc.visit(this); 1549 obj.dirs.visit(this); 1550 obj.ss.visit(this); 1551 break; 1552 case FragmentDefinitionEnum.FTS: 1553 obj.name.visit(this); 1554 obj.tc.visit(this); 1555 obj.ss.visit(this); 1556 break; 1557 } 1558 exit(obj); 1559 } 1560 1561 void enter(const(Directives) obj) {} 1562 void exit(const(Directives) obj) {} 1563 1564 void accept(const(Directives) obj) { 1565 enter(obj); 1566 final switch(obj.ruleSelection) { 1567 case DirectivesEnum.Dir: 1568 obj.dir.visit(this); 1569 break; 1570 case DirectivesEnum.Dirs: 1571 obj.dir.visit(this); 1572 obj.follow.visit(this); 1573 break; 1574 } 1575 exit(obj); 1576 } 1577 1578 void enter(const(Directive) obj) {} 1579 void exit(const(Directive) obj) {} 1580 1581 void accept(const(Directive) obj) { 1582 enter(obj); 1583 final switch(obj.ruleSelection) { 1584 case DirectiveEnum.NArg: 1585 obj.name.visit(this); 1586 obj.arg.visit(this); 1587 break; 1588 case DirectiveEnum.N: 1589 obj.name.visit(this); 1590 break; 1591 } 1592 exit(obj); 1593 } 1594 1595 void enter(const(VariableDefinitions) obj) {} 1596 void exit(const(VariableDefinitions) obj) {} 1597 1598 void accept(const(VariableDefinitions) obj) { 1599 enter(obj); 1600 final switch(obj.ruleSelection) { 1601 case VariableDefinitionsEnum.Empty: 1602 break; 1603 case VariableDefinitionsEnum.Vars: 1604 obj.vars.visit(this); 1605 break; 1606 } 1607 exit(obj); 1608 } 1609 1610 void enter(const(VariableDefinitionList) obj) {} 1611 void exit(const(VariableDefinitionList) obj) {} 1612 1613 void accept(const(VariableDefinitionList) obj) { 1614 enter(obj); 1615 final switch(obj.ruleSelection) { 1616 case VariableDefinitionListEnum.V: 1617 obj.var.visit(this); 1618 break; 1619 case VariableDefinitionListEnum.VCF: 1620 obj.var.visit(this); 1621 obj.follow.visit(this); 1622 break; 1623 case VariableDefinitionListEnum.VF: 1624 obj.var.visit(this); 1625 obj.follow.visit(this); 1626 break; 1627 } 1628 exit(obj); 1629 } 1630 1631 void enter(const(VariableDefinition) obj) {} 1632 void exit(const(VariableDefinition) obj) {} 1633 1634 void accept(const(VariableDefinition) obj) { 1635 enter(obj); 1636 final switch(obj.ruleSelection) { 1637 case VariableDefinitionEnum.VarD: 1638 obj.var.visit(this); 1639 obj.type.visit(this); 1640 obj.dvalue.visit(this); 1641 break; 1642 case VariableDefinitionEnum.Var: 1643 obj.var.visit(this); 1644 obj.type.visit(this); 1645 break; 1646 } 1647 exit(obj); 1648 } 1649 1650 void enter(const(Variable) obj) {} 1651 void exit(const(Variable) obj) {} 1652 1653 void accept(const(Variable) obj) { 1654 enter(obj); 1655 final switch(obj.ruleSelection) { 1656 case VariableEnum.Var: 1657 obj.name.visit(this); 1658 break; 1659 } 1660 exit(obj); 1661 } 1662 1663 void enter(const(DefaultValue) obj) {} 1664 void exit(const(DefaultValue) obj) {} 1665 1666 void accept(const(DefaultValue) obj) { 1667 enter(obj); 1668 final switch(obj.ruleSelection) { 1669 case DefaultValueEnum.DV: 1670 obj.value.visit(this); 1671 break; 1672 } 1673 exit(obj); 1674 } 1675 1676 void enter(const(ValueOrVariable) obj) {} 1677 void exit(const(ValueOrVariable) obj) {} 1678 1679 void accept(const(ValueOrVariable) obj) { 1680 enter(obj); 1681 final switch(obj.ruleSelection) { 1682 case ValueOrVariableEnum.Val: 1683 obj.val.visit(this); 1684 break; 1685 case ValueOrVariableEnum.Var: 1686 obj.var.visit(this); 1687 break; 1688 } 1689 exit(obj); 1690 } 1691 1692 void enter(const(Value) obj) {} 1693 void exit(const(Value) obj) {} 1694 1695 void accept(const(Value) obj) { 1696 enter(obj); 1697 final switch(obj.ruleSelection) { 1698 case ValueEnum.STR: 1699 obj.tok.visit(this); 1700 break; 1701 case ValueEnum.INT: 1702 obj.tok.visit(this); 1703 break; 1704 case ValueEnum.FLOAT: 1705 obj.tok.visit(this); 1706 break; 1707 case ValueEnum.T: 1708 obj.tok.visit(this); 1709 break; 1710 case ValueEnum.F: 1711 obj.tok.visit(this); 1712 break; 1713 case ValueEnum.ARR: 1714 obj.arr.visit(this); 1715 break; 1716 case ValueEnum.O: 1717 obj.obj.visit(this); 1718 break; 1719 case ValueEnum.E: 1720 obj.tok.visit(this); 1721 break; 1722 case ValueEnum.N: 1723 obj.tok.visit(this); 1724 break; 1725 } 1726 exit(obj); 1727 } 1728 1729 void enter(const(Type) obj) {} 1730 void exit(const(Type) obj) {} 1731 1732 void accept(const(Type) obj) { 1733 enter(obj); 1734 final switch(obj.ruleSelection) { 1735 case TypeEnum.TN: 1736 obj.tname.visit(this); 1737 break; 1738 case TypeEnum.LN: 1739 obj.list.visit(this); 1740 break; 1741 case TypeEnum.T: 1742 obj.tname.visit(this); 1743 break; 1744 case TypeEnum.L: 1745 obj.list.visit(this); 1746 break; 1747 } 1748 exit(obj); 1749 } 1750 1751 void enter(const(ListType) obj) {} 1752 void exit(const(ListType) obj) {} 1753 1754 void accept(const(ListType) obj) { 1755 enter(obj); 1756 final switch(obj.ruleSelection) { 1757 case ListTypeEnum.T: 1758 obj.type.visit(this); 1759 break; 1760 } 1761 exit(obj); 1762 } 1763 1764 void enter(const(Values) obj) {} 1765 void exit(const(Values) obj) {} 1766 1767 void accept(const(Values) obj) { 1768 enter(obj); 1769 final switch(obj.ruleSelection) { 1770 case ValuesEnum.Val: 1771 obj.val.visit(this); 1772 break; 1773 case ValuesEnum.Vals: 1774 obj.val.visit(this); 1775 obj.follow.visit(this); 1776 break; 1777 } 1778 exit(obj); 1779 } 1780 1781 void enter(const(Array) obj) {} 1782 void exit(const(Array) obj) {} 1783 1784 void accept(const(Array) obj) { 1785 enter(obj); 1786 final switch(obj.ruleSelection) { 1787 case ArrayEnum.Empty: 1788 break; 1789 case ArrayEnum.Value: 1790 obj.vals.visit(this); 1791 break; 1792 } 1793 exit(obj); 1794 } 1795 1796 void enter(const(ObjectValues) obj) {} 1797 void exit(const(ObjectValues) obj) {} 1798 1799 void accept(const(ObjectValues) obj) { 1800 enter(obj); 1801 final switch(obj.ruleSelection) { 1802 case ObjectValuesEnum.V: 1803 obj.name.visit(this); 1804 obj.val.visit(this); 1805 break; 1806 case ObjectValuesEnum.Vsc: 1807 obj.name.visit(this); 1808 obj.val.visit(this); 1809 obj.follow.visit(this); 1810 break; 1811 case ObjectValuesEnum.Vs: 1812 obj.name.visit(this); 1813 obj.val.visit(this); 1814 obj.follow.visit(this); 1815 break; 1816 } 1817 exit(obj); 1818 } 1819 1820 void enter(const(ObjectType) obj) {} 1821 void exit(const(ObjectType) obj) {} 1822 1823 void accept(const(ObjectType) obj) { 1824 enter(obj); 1825 final switch(obj.ruleSelection) { 1826 case ObjectTypeEnum.Var: 1827 obj.vals.visit(this); 1828 break; 1829 } 1830 exit(obj); 1831 } 1832 1833 void enter(const(TypeSystemDefinition) obj) {} 1834 void exit(const(TypeSystemDefinition) obj) {} 1835 1836 void accept(const(TypeSystemDefinition) obj) { 1837 enter(obj); 1838 final switch(obj.ruleSelection) { 1839 case TypeSystemDefinitionEnum.S: 1840 obj.sch.visit(this); 1841 break; 1842 case TypeSystemDefinitionEnum.T: 1843 obj.td.visit(this); 1844 break; 1845 case TypeSystemDefinitionEnum.TE: 1846 obj.ted.visit(this); 1847 break; 1848 case TypeSystemDefinitionEnum.D: 1849 obj.dd.visit(this); 1850 break; 1851 case TypeSystemDefinitionEnum.DS: 1852 obj.des.visit(this); 1853 obj.sch.visit(this); 1854 break; 1855 case TypeSystemDefinitionEnum.DT: 1856 obj.des.visit(this); 1857 obj.td.visit(this); 1858 break; 1859 case TypeSystemDefinitionEnum.DTE: 1860 obj.des.visit(this); 1861 obj.ted.visit(this); 1862 break; 1863 case TypeSystemDefinitionEnum.DD: 1864 obj.des.visit(this); 1865 obj.dd.visit(this); 1866 break; 1867 } 1868 exit(obj); 1869 } 1870 1871 void enter(const(TypeDefinition) obj) {} 1872 void exit(const(TypeDefinition) obj) {} 1873 1874 void accept(const(TypeDefinition) obj) { 1875 enter(obj); 1876 final switch(obj.ruleSelection) { 1877 case TypeDefinitionEnum.S: 1878 obj.std.visit(this); 1879 break; 1880 case TypeDefinitionEnum.O: 1881 obj.otd.visit(this); 1882 break; 1883 case TypeDefinitionEnum.I: 1884 obj.itd.visit(this); 1885 break; 1886 case TypeDefinitionEnum.U: 1887 obj.utd.visit(this); 1888 break; 1889 case TypeDefinitionEnum.E: 1890 obj.etd.visit(this); 1891 break; 1892 case TypeDefinitionEnum.IO: 1893 obj.iod.visit(this); 1894 break; 1895 } 1896 exit(obj); 1897 } 1898 1899 void enter(const(SchemaDefinition) obj) {} 1900 void exit(const(SchemaDefinition) obj) {} 1901 1902 void accept(const(SchemaDefinition) obj) { 1903 enter(obj); 1904 final switch(obj.ruleSelection) { 1905 case SchemaDefinitionEnum.DO: 1906 obj.dir.visit(this); 1907 obj.otds.visit(this); 1908 break; 1909 case SchemaDefinitionEnum.O: 1910 obj.otds.visit(this); 1911 break; 1912 } 1913 exit(obj); 1914 } 1915 1916 void enter(const(OperationTypeDefinitions) obj) {} 1917 void exit(const(OperationTypeDefinitions) obj) {} 1918 1919 void accept(const(OperationTypeDefinitions) obj) { 1920 enter(obj); 1921 final switch(obj.ruleSelection) { 1922 case OperationTypeDefinitionsEnum.O: 1923 obj.otd.visit(this); 1924 break; 1925 case OperationTypeDefinitionsEnum.OCS: 1926 obj.otd.visit(this); 1927 obj.follow.visit(this); 1928 break; 1929 case OperationTypeDefinitionsEnum.OS: 1930 obj.otd.visit(this); 1931 obj.follow.visit(this); 1932 break; 1933 } 1934 exit(obj); 1935 } 1936 1937 void enter(const(OperationTypeDefinition) obj) {} 1938 void exit(const(OperationTypeDefinition) obj) {} 1939 1940 void accept(const(OperationTypeDefinition) obj) { 1941 enter(obj); 1942 final switch(obj.ruleSelection) { 1943 case OperationTypeDefinitionEnum.O: 1944 obj.ot.visit(this); 1945 obj.nt.visit(this); 1946 break; 1947 } 1948 exit(obj); 1949 } 1950 1951 void enter(const(ScalarTypeDefinition) obj) {} 1952 void exit(const(ScalarTypeDefinition) obj) {} 1953 1954 void accept(const(ScalarTypeDefinition) obj) { 1955 enter(obj); 1956 final switch(obj.ruleSelection) { 1957 case ScalarTypeDefinitionEnum.D: 1958 obj.name.visit(this); 1959 obj.dir.visit(this); 1960 break; 1961 case ScalarTypeDefinitionEnum.S: 1962 obj.name.visit(this); 1963 break; 1964 } 1965 exit(obj); 1966 } 1967 1968 void enter(const(ObjectTypeDefinition) obj) {} 1969 void exit(const(ObjectTypeDefinition) obj) {} 1970 1971 void accept(const(ObjectTypeDefinition) obj) { 1972 enter(obj); 1973 final switch(obj.ruleSelection) { 1974 case ObjectTypeDefinitionEnum.ID: 1975 obj.name.visit(this); 1976 obj.ii.visit(this); 1977 obj.dir.visit(this); 1978 obj.fds.visit(this); 1979 break; 1980 case ObjectTypeDefinitionEnum.I: 1981 obj.name.visit(this); 1982 obj.ii.visit(this); 1983 obj.fds.visit(this); 1984 break; 1985 case ObjectTypeDefinitionEnum.D: 1986 obj.name.visit(this); 1987 obj.dir.visit(this); 1988 obj.fds.visit(this); 1989 break; 1990 case ObjectTypeDefinitionEnum.F: 1991 obj.name.visit(this); 1992 obj.fds.visit(this); 1993 break; 1994 } 1995 exit(obj); 1996 } 1997 1998 void enter(const(FieldDefinitions) obj) {} 1999 void exit(const(FieldDefinitions) obj) {} 2000 2001 void accept(const(FieldDefinitions) obj) { 2002 enter(obj); 2003 final switch(obj.ruleSelection) { 2004 case FieldDefinitionsEnum.F: 2005 obj.fd.visit(this); 2006 break; 2007 case FieldDefinitionsEnum.FC: 2008 obj.fd.visit(this); 2009 obj.follow.visit(this); 2010 break; 2011 case FieldDefinitionsEnum.FNC: 2012 obj.fd.visit(this); 2013 obj.follow.visit(this); 2014 break; 2015 } 2016 exit(obj); 2017 } 2018 2019 void enter(const(FieldDefinition) obj) {} 2020 void exit(const(FieldDefinition) obj) {} 2021 2022 void accept(const(FieldDefinition) obj) { 2023 enter(obj); 2024 final switch(obj.ruleSelection) { 2025 case FieldDefinitionEnum.AD: 2026 obj.name.visit(this); 2027 obj.arg.visit(this); 2028 obj.typ.visit(this); 2029 obj.dir.visit(this); 2030 break; 2031 case FieldDefinitionEnum.A: 2032 obj.name.visit(this); 2033 obj.arg.visit(this); 2034 obj.typ.visit(this); 2035 break; 2036 case FieldDefinitionEnum.D: 2037 obj.name.visit(this); 2038 obj.typ.visit(this); 2039 obj.dir.visit(this); 2040 break; 2041 case FieldDefinitionEnum.T: 2042 obj.name.visit(this); 2043 obj.typ.visit(this); 2044 break; 2045 case FieldDefinitionEnum.DAD: 2046 obj.des.visit(this); 2047 obj.name.visit(this); 2048 obj.arg.visit(this); 2049 obj.typ.visit(this); 2050 obj.dir.visit(this); 2051 break; 2052 case FieldDefinitionEnum.DA: 2053 obj.des.visit(this); 2054 obj.name.visit(this); 2055 obj.arg.visit(this); 2056 obj.typ.visit(this); 2057 break; 2058 case FieldDefinitionEnum.DD: 2059 obj.des.visit(this); 2060 obj.name.visit(this); 2061 obj.typ.visit(this); 2062 obj.dir.visit(this); 2063 break; 2064 case FieldDefinitionEnum.DT: 2065 obj.des.visit(this); 2066 obj.name.visit(this); 2067 obj.typ.visit(this); 2068 break; 2069 } 2070 exit(obj); 2071 } 2072 2073 void enter(const(ImplementsInterfaces) obj) {} 2074 void exit(const(ImplementsInterfaces) obj) {} 2075 2076 void accept(const(ImplementsInterfaces) obj) { 2077 enter(obj); 2078 final switch(obj.ruleSelection) { 2079 case ImplementsInterfacesEnum.N: 2080 obj.nts.visit(this); 2081 break; 2082 } 2083 exit(obj); 2084 } 2085 2086 void enter(const(NamedTypes) obj) {} 2087 void exit(const(NamedTypes) obj) {} 2088 2089 void accept(const(NamedTypes) obj) { 2090 enter(obj); 2091 final switch(obj.ruleSelection) { 2092 case NamedTypesEnum.N: 2093 obj.name.visit(this); 2094 break; 2095 case NamedTypesEnum.NCS: 2096 obj.name.visit(this); 2097 obj.follow.visit(this); 2098 break; 2099 case NamedTypesEnum.NS: 2100 obj.name.visit(this); 2101 obj.follow.visit(this); 2102 break; 2103 } 2104 exit(obj); 2105 } 2106 2107 void enter(const(ArgumentsDefinition) obj) {} 2108 void exit(const(ArgumentsDefinition) obj) {} 2109 2110 void accept(const(ArgumentsDefinition) obj) { 2111 enter(obj); 2112 final switch(obj.ruleSelection) { 2113 case ArgumentsDefinitionEnum.A: 2114 break; 2115 case ArgumentsDefinitionEnum.DA: 2116 obj.des.visit(this); 2117 break; 2118 } 2119 exit(obj); 2120 } 2121 2122 void enter(const(InputValueDefinitions) obj) {} 2123 void exit(const(InputValueDefinitions) obj) {} 2124 2125 void accept(const(InputValueDefinitions) obj) { 2126 enter(obj); 2127 final switch(obj.ruleSelection) { 2128 case InputValueDefinitionsEnum.I: 2129 obj.iv.visit(this); 2130 break; 2131 case InputValueDefinitionsEnum.ICF: 2132 obj.iv.visit(this); 2133 obj.follow.visit(this); 2134 break; 2135 case InputValueDefinitionsEnum.IF: 2136 obj.iv.visit(this); 2137 obj.follow.visit(this); 2138 break; 2139 } 2140 exit(obj); 2141 } 2142 2143 void enter(const(InputValueDefinition) obj) {} 2144 void exit(const(InputValueDefinition) obj) {} 2145 2146 void accept(const(InputValueDefinition) obj) { 2147 enter(obj); 2148 final switch(obj.ruleSelection) { 2149 case InputValueDefinitionEnum.TVD: 2150 obj.name.visit(this); 2151 obj.type.visit(this); 2152 obj.df.visit(this); 2153 obj.dirs.visit(this); 2154 break; 2155 case InputValueDefinitionEnum.TD: 2156 obj.name.visit(this); 2157 obj.type.visit(this); 2158 obj.dirs.visit(this); 2159 break; 2160 case InputValueDefinitionEnum.TV: 2161 obj.name.visit(this); 2162 obj.type.visit(this); 2163 obj.df.visit(this); 2164 break; 2165 case InputValueDefinitionEnum.T: 2166 obj.name.visit(this); 2167 obj.type.visit(this); 2168 break; 2169 } 2170 exit(obj); 2171 } 2172 2173 void enter(const(InterfaceTypeDefinition) obj) {} 2174 void exit(const(InterfaceTypeDefinition) obj) {} 2175 2176 void accept(const(InterfaceTypeDefinition) obj) { 2177 enter(obj); 2178 final switch(obj.ruleSelection) { 2179 case InterfaceTypeDefinitionEnum.NDF: 2180 obj.name.visit(this); 2181 obj.dirs.visit(this); 2182 obj.fds.visit(this); 2183 break; 2184 case InterfaceTypeDefinitionEnum.NF: 2185 obj.name.visit(this); 2186 obj.fds.visit(this); 2187 break; 2188 } 2189 exit(obj); 2190 } 2191 2192 void enter(const(UnionTypeDefinition) obj) {} 2193 void exit(const(UnionTypeDefinition) obj) {} 2194 2195 void accept(const(UnionTypeDefinition) obj) { 2196 enter(obj); 2197 final switch(obj.ruleSelection) { 2198 case UnionTypeDefinitionEnum.NDU: 2199 obj.name.visit(this); 2200 obj.dirs.visit(this); 2201 obj.um.visit(this); 2202 break; 2203 case UnionTypeDefinitionEnum.NU: 2204 obj.name.visit(this); 2205 obj.um.visit(this); 2206 break; 2207 } 2208 exit(obj); 2209 } 2210 2211 void enter(const(UnionMembers) obj) {} 2212 void exit(const(UnionMembers) obj) {} 2213 2214 void accept(const(UnionMembers) obj) { 2215 enter(obj); 2216 final switch(obj.ruleSelection) { 2217 case UnionMembersEnum.S: 2218 obj.name.visit(this); 2219 break; 2220 case UnionMembersEnum.SPF: 2221 obj.name.visit(this); 2222 obj.follow.visit(this); 2223 break; 2224 case UnionMembersEnum.SF: 2225 obj.name.visit(this); 2226 obj.follow.visit(this); 2227 break; 2228 } 2229 exit(obj); 2230 } 2231 2232 void enter(const(EnumTypeDefinition) obj) {} 2233 void exit(const(EnumTypeDefinition) obj) {} 2234 2235 void accept(const(EnumTypeDefinition) obj) { 2236 enter(obj); 2237 final switch(obj.ruleSelection) { 2238 case EnumTypeDefinitionEnum.NDE: 2239 obj.name.visit(this); 2240 obj.dir.visit(this); 2241 obj.evds.visit(this); 2242 break; 2243 case EnumTypeDefinitionEnum.NE: 2244 obj.name.visit(this); 2245 obj.evds.visit(this); 2246 break; 2247 } 2248 exit(obj); 2249 } 2250 2251 void enter(const(EnumValueDefinitions) obj) {} 2252 void exit(const(EnumValueDefinitions) obj) {} 2253 2254 void accept(const(EnumValueDefinitions) obj) { 2255 enter(obj); 2256 final switch(obj.ruleSelection) { 2257 case EnumValueDefinitionsEnum.D: 2258 obj.evd.visit(this); 2259 break; 2260 case EnumValueDefinitionsEnum.DCE: 2261 obj.evd.visit(this); 2262 obj.follow.visit(this); 2263 break; 2264 case EnumValueDefinitionsEnum.DE: 2265 obj.evd.visit(this); 2266 obj.follow.visit(this); 2267 break; 2268 } 2269 exit(obj); 2270 } 2271 2272 void enter(const(EnumValueDefinition) obj) {} 2273 void exit(const(EnumValueDefinition) obj) {} 2274 2275 void accept(const(EnumValueDefinition) obj) { 2276 enter(obj); 2277 final switch(obj.ruleSelection) { 2278 case EnumValueDefinitionEnum.ED: 2279 obj.name.visit(this); 2280 obj.dirs.visit(this); 2281 break; 2282 case EnumValueDefinitionEnum.E: 2283 obj.name.visit(this); 2284 break; 2285 } 2286 exit(obj); 2287 } 2288 2289 void enter(const(InputTypeDefinition) obj) {} 2290 void exit(const(InputTypeDefinition) obj) {} 2291 2292 void accept(const(InputTypeDefinition) obj) { 2293 enter(obj); 2294 final switch(obj.ruleSelection) { 2295 case InputTypeDefinitionEnum.NDE: 2296 obj.name.visit(this); 2297 obj.dir.visit(this); 2298 obj.ivds.visit(this); 2299 break; 2300 case InputTypeDefinitionEnum.NE: 2301 obj.name.visit(this); 2302 obj.ivds.visit(this); 2303 break; 2304 } 2305 exit(obj); 2306 } 2307 2308 void enter(const(TypeExtensionDefinition) obj) {} 2309 void exit(const(TypeExtensionDefinition) obj) {} 2310 2311 void accept(const(TypeExtensionDefinition) obj) { 2312 enter(obj); 2313 final switch(obj.ruleSelection) { 2314 case TypeExtensionDefinitionEnum.O: 2315 obj.otd.visit(this); 2316 break; 2317 } 2318 exit(obj); 2319 } 2320 2321 void enter(const(DirectiveDefinition) obj) {} 2322 void exit(const(DirectiveDefinition) obj) {} 2323 2324 void accept(const(DirectiveDefinition) obj) { 2325 enter(obj); 2326 final switch(obj.ruleSelection) { 2327 case DirectiveDefinitionEnum.AD: 2328 obj.name.visit(this); 2329 obj.ad.visit(this); 2330 obj.dl.visit(this); 2331 break; 2332 case DirectiveDefinitionEnum.D: 2333 obj.name.visit(this); 2334 obj.dl.visit(this); 2335 break; 2336 } 2337 exit(obj); 2338 } 2339 2340 void enter(const(DirectiveLocations) obj) {} 2341 void exit(const(DirectiveLocations) obj) {} 2342 2343 void accept(const(DirectiveLocations) obj) { 2344 enter(obj); 2345 final switch(obj.ruleSelection) { 2346 case DirectiveLocationsEnum.N: 2347 obj.name.visit(this); 2348 break; 2349 case DirectiveLocationsEnum.NPF: 2350 obj.name.visit(this); 2351 obj.follow.visit(this); 2352 break; 2353 case DirectiveLocationsEnum.NF: 2354 obj.name.visit(this); 2355 obj.follow.visit(this); 2356 break; 2357 } 2358 exit(obj); 2359 } 2360 2361 void enter(const(InputObjectTypeDefinition) obj) {} 2362 void exit(const(InputObjectTypeDefinition) obj) {} 2363 2364 void accept(const(InputObjectTypeDefinition) obj) { 2365 enter(obj); 2366 final switch(obj.ruleSelection) { 2367 case InputObjectTypeDefinitionEnum.NDI: 2368 obj.name.visit(this); 2369 obj.dirs.visit(this); 2370 break; 2371 case InputObjectTypeDefinitionEnum.NI: 2372 obj.name.visit(this); 2373 break; 2374 } 2375 exit(obj); 2376 } 2377 2378 void enter(const(Description) obj) {} 2379 void exit(const(Description) obj) {} 2380 2381 void accept(const(Description) obj) { 2382 enter(obj); 2383 final switch(obj.ruleSelection) { 2384 case DescriptionEnum.S: 2385 obj.tok.visit(this); 2386 break; 2387 } 2388 exit(obj); 2389 } 2390 } 2391