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