libclang_ast.ast.directive source code

1 /**
2 Copyright: Copyright (c) 2016, Joakim Brännström. All rights reserved.
3 License: MPL-2
4 Author: Joakim Brännström (joakim.brannstrom@gmx.com)
5 
6 This Source Code Form is subject to the terms of the Mozilla Public License,
7 v.2.0. If a copy of the MPL was not distributed with this file, You can obtain
8 one at http://mozilla.org/MPL/2.0/.
9 
10 DO NOT EDIT. THIS FILE IS GENERATED.
11 See the generator script source/devtool/generator_clang_ast_nodes.d
12 */
13 module libclang_ast.ast.directive;
14 import libclang_ast.ast.node : Node;
15 
16 abstract class Directive : Node {
17     import clang.Cursor : Cursor;
18     import libclang_ast.ast : Visitor;
19 
20     Cursor cursor;
21     alias cursor this;
22 
23     this(Cursor cursor) @safe {
24         this.cursor = cursor;
25     }
26 
27     override void accept(Visitor v) @safe const {
28         static import libclang_ast.ast;
29 
30         libclang_ast.ast.accept(cursor, v);
31     }
32 }
33 
34 final class OmpParallelDirective : Directive {
35     import clang.Cursor : Cursor;
36 
37     this(Cursor cursor) @safe {
38         super(cursor);
39     }
40 
41     override void accept(Visitor v) @safe const {
42         static import libclang_ast.ast;
43 
44         libclang_ast.ast.accept(cursor, v);
45     }
46 }
47 
48 final class OmpSimdDirective : Directive {
49     import clang.Cursor : Cursor;
50 
51     this(Cursor cursor) @safe {
52         super(cursor);
53     }
54 
55     override void accept(Visitor v) @safe const {
56         static import libclang_ast.ast;
57 
58         libclang_ast.ast.accept(cursor, v);
59     }
60 }
61 
62 final class OmpForDirective : Directive {
63     import clang.Cursor : Cursor;
64 
65     this(Cursor cursor) @safe {
66         super(cursor);
67     }
68 
69     override void accept(Visitor v) @safe const {
70         static import libclang_ast.ast;
71 
72         libclang_ast.ast.accept(cursor, v);
73     }
74 }
75 
76 final class OmpSectionsDirective : Directive {
77     import clang.Cursor : Cursor;
78 
79     this(Cursor cursor) @safe {
80         super(cursor);
81     }
82 
83     override void accept(Visitor v) @safe const {
84         static import libclang_ast.ast;
85 
86         libclang_ast.ast.accept(cursor, v);
87     }
88 }
89 
90 final class OmpSectionDirective : Directive {
91     import clang.Cursor : Cursor;
92 
93     this(Cursor cursor) @safe {
94         super(cursor);
95     }
96 
97     override void accept(Visitor v) @safe const {
98         static import libclang_ast.ast;
99 
100         libclang_ast.ast.accept(cursor, v);
101     }
102 }
103 
104 final class OmpSingleDirective : Directive {
105     import clang.Cursor : Cursor;
106 
107     this(Cursor cursor) @safe {
108         super(cursor);
109     }
110 
111     override void accept(Visitor v) @safe const {
112         static import libclang_ast.ast;
113 
114         libclang_ast.ast.accept(cursor, v);
115     }
116 }
117 
118 final class OmpParallelForDirective : Directive {
119     import clang.Cursor : Cursor;
120 
121     this(Cursor cursor) @safe {
122         super(cursor);
123     }
124 
125     override void accept(Visitor v) @safe const {
126         static import libclang_ast.ast;
127 
128         libclang_ast.ast.accept(cursor, v);
129     }
130 }
131 
132 final class OmpParallelSectionsDirective : Directive {
133     import clang.Cursor : Cursor;
134 
135     this(Cursor cursor) @safe {
136         super(cursor);
137     }
138 
139     override void accept(Visitor v) @safe const {
140         static import libclang_ast.ast;
141 
142         libclang_ast.ast.accept(cursor, v);
143     }
144 }
145 
146 final class OmpTaskDirective : Directive {
147     import clang.Cursor : Cursor;
148 
149     this(Cursor cursor) @safe {
150         super(cursor);
151     }
152 
153     override void accept(Visitor v) @safe const {
154         static import libclang_ast.ast;
155 
156         libclang_ast.ast.accept(cursor, v);
157     }
158 }
159 
160 final class OmpMasterDirective : Directive {
161     import clang.Cursor : Cursor;
162 
163     this(Cursor cursor) @safe {
164         super(cursor);
165     }
166 
167     override void accept(Visitor v) @safe const {
168         static import libclang_ast.ast;
169 
170         libclang_ast.ast.accept(cursor, v);
171     }
172 }
173 
174 final class OmpCriticalDirective : Directive {
175     import clang.Cursor : Cursor;
176 
177     this(Cursor cursor) @safe {
178         super(cursor);
179     }
180 
181     override void accept(Visitor v) @safe const {
182         static import libclang_ast.ast;
183 
184         libclang_ast.ast.accept(cursor, v);
185     }
186 }
187 
188 final class OmpTaskyieldDirective : Directive {
189     import clang.Cursor : Cursor;
190 
191     this(Cursor cursor) @safe {
192         super(cursor);
193     }
194 
195     override void accept(Visitor v) @safe const {
196         static import libclang_ast.ast;
197 
198         libclang_ast.ast.accept(cursor, v);
199     }
200 }
201 
202 final class OmpBarrierDirective : Directive {
203     import clang.Cursor : Cursor;
204 
205     this(Cursor cursor) @safe {
206         super(cursor);
207     }
208 
209     override void accept(Visitor v) @safe const {
210         static import libclang_ast.ast;
211 
212         libclang_ast.ast.accept(cursor, v);
213     }
214 }
215 
216 final class OmpTaskwaitDirective : Directive {
217     import clang.Cursor : Cursor;
218 
219     this(Cursor cursor) @safe {
220         super(cursor);
221     }
222 
223     override void accept(Visitor v) @safe const {
224         static import libclang_ast.ast;
225 
226         libclang_ast.ast.accept(cursor, v);
227     }
228 }
229 
230 final class OmpFlushDirective : Directive {
231     import clang.Cursor : Cursor;
232 
233     this(Cursor cursor) @safe {
234         super(cursor);
235     }
236 
237     override void accept(Visitor v) @safe const {
238         static import libclang_ast.ast;
239 
240         libclang_ast.ast.accept(cursor, v);
241     }
242 }
243 
244 final class OmpOrderedDirective : Directive {
245     import clang.Cursor : Cursor;
246 
247     this(Cursor cursor) @safe {
248         super(cursor);
249     }
250 
251     override void accept(Visitor v) @safe const {
252         static import libclang_ast.ast;
253 
254         libclang_ast.ast.accept(cursor, v);
255     }
256 }
257 
258 final class OmpAtomicDirective : Directive {
259     import clang.Cursor : Cursor;
260 
261     this(Cursor cursor) @safe {
262         super(cursor);
263     }
264 
265     override void accept(Visitor v) @safe const {
266         static import libclang_ast.ast;
267 
268         libclang_ast.ast.accept(cursor, v);
269     }
270 }
271 
272 final class OmpForSimdDirective : Directive {
273     import clang.Cursor : Cursor;
274 
275     this(Cursor cursor) @safe {
276         super(cursor);
277     }
278 
279     override void accept(Visitor v) @safe const {
280         static import libclang_ast.ast;
281 
282         libclang_ast.ast.accept(cursor, v);
283     }
284 }
285 
286 final class OmpParallelForSimdDirective : Directive {
287     import clang.Cursor : Cursor;
288 
289     this(Cursor cursor) @safe {
290         super(cursor);
291     }
292 
293     override void accept(Visitor v) @safe const {
294         static import libclang_ast.ast;
295 
296         libclang_ast.ast.accept(cursor, v);
297     }
298 }
299 
300 final class OmpTargetDirective : Directive {
301     import clang.Cursor : Cursor;
302 
303     this(Cursor cursor) @safe {
304         super(cursor);
305     }
306 
307     override void accept(Visitor v) @safe const {
308         static import libclang_ast.ast;
309 
310         libclang_ast.ast.accept(cursor, v);
311     }
312 }
313 
314 final class OmpTeamsDirective : Directive {
315     import clang.Cursor : Cursor;
316 
317     this(Cursor cursor) @safe {
318         super(cursor);
319     }
320 
321     override void accept(Visitor v) @safe const {
322         static import libclang_ast.ast;
323 
324         libclang_ast.ast.accept(cursor, v);
325     }
326 }
327 
328 final class OmpTaskgroupDirective : Directive {
329     import clang.Cursor : Cursor;
330 
331     this(Cursor cursor) @safe {
332         super(cursor);
333     }
334 
335     override void accept(Visitor v) @safe const {
336         static import libclang_ast.ast;
337 
338         libclang_ast.ast.accept(cursor, v);
339     }
340 }
341 
342 final class OmpCancellationPointDirective : Directive {
343     import clang.Cursor : Cursor;
344 
345     this(Cursor cursor) @safe {
346         super(cursor);
347     }
348 
349     override void accept(Visitor v) @safe const {
350         static import libclang_ast.ast;
351 
352         libclang_ast.ast.accept(cursor, v);
353     }
354 }
355 
356 final class OmpCancelDirective : Directive {
357     import clang.Cursor : Cursor;
358 
359     this(Cursor cursor) @safe {
360         super(cursor);
361     }
362 
363     override void accept(Visitor v) @safe const {
364         static import libclang_ast.ast;
365 
366         libclang_ast.ast.accept(cursor, v);
367     }
368 }
369 
370 final class OmpTargetDataDirective : Directive {
371     import clang.Cursor : Cursor;
372 
373     this(Cursor cursor) @safe {
374         super(cursor);
375     }
376 
377     override void accept(Visitor v) @safe const {
378         static import libclang_ast.ast;
379 
380         libclang_ast.ast.accept(cursor, v);
381     }
382 }
383 
384 final class OmpTaskLoopDirective : Directive {
385     import clang.Cursor : Cursor;
386 
387     this(Cursor cursor) @safe {
388         super(cursor);
389     }
390 
391     override void accept(Visitor v) @safe const {
392         static import libclang_ast.ast;
393 
394         libclang_ast.ast.accept(cursor, v);
395     }
396 }
397 
398 final class OmpTaskLoopSimdDirective : Directive {
399     import clang.Cursor : Cursor;
400 
401     this(Cursor cursor) @safe {
402         super(cursor);
403     }
404 
405     override void accept(Visitor v) @safe const {
406         static import libclang_ast.ast;
407 
408         libclang_ast.ast.accept(cursor, v);
409     }
410 }
411 
412 final class OmpDistributeDirective : Directive {
413     import clang.Cursor : Cursor;
414 
415     this(Cursor cursor) @safe {
416         super(cursor);
417     }
418 
419     override void accept(Visitor v) @safe const {
420         static import libclang_ast.ast;
421 
422         libclang_ast.ast.accept(cursor, v);
423     }
424 }
425 
426 final class OmpTargetEnterDataDirective : Directive {
427     import clang.Cursor : Cursor;
428 
429     this(Cursor cursor) @safe {
430         super(cursor);
431     }
432 
433     override void accept(Visitor v) @safe const {
434         static import libclang_ast.ast;
435 
436         libclang_ast.ast.accept(cursor, v);
437     }
438 }
439 
440 final class OmpTargetExitDataDirective : Directive {
441     import clang.Cursor : Cursor;
442 
443     this(Cursor cursor) @safe {
444         super(cursor);
445     }
446 
447     override void accept(Visitor v) @safe const {
448         static import libclang_ast.ast;
449 
450         libclang_ast.ast.accept(cursor, v);
451     }
452 }
453 
454 final class OmpTargetParallelDirective : Directive {
455     import clang.Cursor : Cursor;
456 
457     this(Cursor cursor) @safe {
458         super(cursor);
459     }
460 
461     override void accept(Visitor v) @safe const {
462         static import libclang_ast.ast;
463 
464         libclang_ast.ast.accept(cursor, v);
465     }
466 }
467 
468 final class OmpTargetParallelForDirective : Directive {
469     import clang.Cursor : Cursor;
470 
471     this(Cursor cursor) @safe {
472         super(cursor);
473     }
474 
475     override void accept(Visitor v) @safe const {
476         static import libclang_ast.ast;
477 
478         libclang_ast.ast.accept(cursor, v);
479     }
480 }
481 
482 final class OmpTargetUpdateDirective : Directive {
483     import clang.Cursor : Cursor;
484 
485     this(Cursor cursor) @safe {
486         super(cursor);
487     }
488 
489     override void accept(Visitor v) @safe const {
490         static import libclang_ast.ast;
491 
492         libclang_ast.ast.accept(cursor, v);
493     }
494 }
495 
496 final class OmpDistributeParallelForDirective : Directive {
497     import clang.Cursor : Cursor;
498 
499     this(Cursor cursor) @safe {
500         super(cursor);
501     }
502 
503     override void accept(Visitor v) @safe const {
504         static import libclang_ast.ast;
505 
506         libclang_ast.ast.accept(cursor, v);
507     }
508 }
509 
510 final class OmpDistributeParallelForSimdDirective : Directive {
511     import clang.Cursor : Cursor;
512 
513     this(Cursor cursor) @safe {
514         super(cursor);
515     }
516 
517     override void accept(Visitor v) @safe const {
518         static import libclang_ast.ast;
519 
520         libclang_ast.ast.accept(cursor, v);
521     }
522 }
523 
524 final class OmpDistributeSimdDirective : Directive {
525     import clang.Cursor : Cursor;
526 
527     this(Cursor cursor) @safe {
528         super(cursor);
529     }
530 
531     override void accept(Visitor v) @safe const {
532         static import libclang_ast.ast;
533 
534         libclang_ast.ast.accept(cursor, v);
535     }
536 }
537 
538 final class OmpTargetParallelForSimdDirective : Directive {
539     import clang.Cursor : Cursor;
540 
541     this(Cursor cursor) @safe {
542         super(cursor);
543     }
544 
545     override void accept(Visitor v) @safe const {
546         static import libclang_ast.ast;
547 
548         libclang_ast.ast.accept(cursor, v);
549     }
550 }
551 
552 final class OmpTargetSimdDirective : Directive {
553     import clang.Cursor : Cursor;
554 
555     this(Cursor cursor) @safe {
556         super(cursor);
557     }
558 
559     override void accept(Visitor v) @safe const {
560         static import libclang_ast.ast;
561 
562         libclang_ast.ast.accept(cursor, v);
563     }
564 }
565 
566 final class OmpTeamsDistributeDirective : Directive {
567     import clang.Cursor : Cursor;
568 
569     this(Cursor cursor) @safe {
570         super(cursor);
571     }
572 
573     override void accept(Visitor v) @safe const {
574         static import libclang_ast.ast;
575 
576         libclang_ast.ast.accept(cursor, v);
577     }
578 }
579 
580 final class OmpTeamsDistributeSimdDirective : Directive {
581     import clang.Cursor : Cursor;
582 
583     this(Cursor cursor) @safe {
584         super(cursor);
585     }
586 
587     override void accept(Visitor v) @safe const {
588         static import libclang_ast.ast;
589 
590         libclang_ast.ast.accept(cursor, v);
591     }
592 }
593 
594 final class OmpTeamsDistributeParallelForSimdDirective : Directive {
595     import clang.Cursor : Cursor;
596 
597     this(Cursor cursor) @safe {
598         super(cursor);
599     }
600 
601     override void accept(Visitor v) @safe const {
602         static import libclang_ast.ast;
603 
604         libclang_ast.ast.accept(cursor, v);
605     }
606 }
607 
608 final class OmpTeamsDistributeParallelForDirective : Directive {
609     import clang.Cursor : Cursor;
610 
611     this(Cursor cursor) @safe {
612         super(cursor);
613     }
614 
615     override void accept(Visitor v) @safe const {
616         static import libclang_ast.ast;
617 
618         libclang_ast.ast.accept(cursor, v);
619     }
620 }
621 
622 final class OmpTargetTeamsDirective : Directive {
623     import clang.Cursor : Cursor;
624 
625     this(Cursor cursor) @safe {
626         super(cursor);
627     }
628 
629     override void accept(Visitor v) @safe const {
630         static import libclang_ast.ast;
631 
632         libclang_ast.ast.accept(cursor, v);
633     }
634 }
635 
636 final class OmpTargetTeamsDistributeDirective : Directive {
637     import clang.Cursor : Cursor;
638 
639     this(Cursor cursor) @safe {
640         super(cursor);
641     }
642 
643     override void accept(Visitor v) @safe const {
644         static import libclang_ast.ast;
645 
646         libclang_ast.ast.accept(cursor, v);
647     }
648 }
649 
650 final class OmpTargetTeamsDistributeParallelForDirective : Directive {
651     import clang.Cursor : Cursor;
652 
653     this(Cursor cursor) @safe {
654         super(cursor);
655     }
656 
657     override void accept(Visitor v) @safe const {
658         static import libclang_ast.ast;
659 
660         libclang_ast.ast.accept(cursor, v);
661     }
662 }
663 
664 final class OmpTargetTeamsDistributeParallelForSimdDirective : Directive {
665     import clang.Cursor : Cursor;
666 
667     this(Cursor cursor) @safe {
668         super(cursor);
669     }
670 
671     override void accept(Visitor v) @safe const {
672         static import libclang_ast.ast;
673 
674         libclang_ast.ast.accept(cursor, v);
675     }
676 }
677 
678 final class OmpTargetTeamsDistributeSimdDirective : Directive {
679     import clang.Cursor : Cursor;
680 
681     this(Cursor cursor) @safe {
682         super(cursor);
683     }
684 
685     override void accept(Visitor v) @safe const {
686         static import libclang_ast.ast;
687 
688         libclang_ast.ast.accept(cursor, v);
689     }
690 }