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