Debian Codegraph @

clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.rst

raw
1 .. title:: clang-tidy - readability-identifier-naming
2
3 readability-identifier-naming
4 =============================
5
6 Checks for identifiers naming style mismatch.
7
8 This check will try to enforce coding guidelines on the identifiers naming. It
9 supports one of the following casing types and tries to convert from one to
10 another if a mismatch is detected
11
12 Casing types include:
13
14 - ``lower_case``
15 - ``UPPER_CASE``
16 - ``camelBack``
17 - ``CamelCase``
18 - ``camel_Snake_Back``
19 - ``Camel_Snake_Case``
20 - ``aNy_CasE``
21 - ``Leading_upper_snake_case``
22
23 It also supports a fixed prefix and suffix that will be prepended or appended
24 to the identifiers, regardless of the casing.
25
26 Many configuration options are available, in order to be able to create
27 different rules for different kinds of identifiers. In general, the rules are
28 falling back to a more generic rule if the specific case is not configured.
29
30 The naming of virtual methods is reported where they occur in the base class,
31 but not where they are overridden, as it can't be fixed locally there.
32 This also applies for pseudo-override patterns like CRTP.
33
34 ``Leading_upper_snake_case`` is a naming convention where the first word is capitalized
35 followed by lower case word(s) separated by underscore(s) '_'. Examples include:
36 `Cap_snake_case`, `Cobra_case`, `Foo_bar_baz`, and `Master_copy_8gb`.
37
38 Hungarian notation can be customized using different *HungarianPrefix* settings.
39 The options and their corresponding values are:
40
41 - ``Off`` - the default setting
42 - ``On`` - example: ``int iVariable``
43 - ``LowerCase`` - example: ``int i_Variable``
44 - ``CamelCase`` - example: ``int IVariable``
45
46 Options
47 -------
48
49 The following options are described below:
50
51 - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`, :option:`AbstractClassSuffix`, :option:`AbstractClassIgnoredRegexp`, :option:`AbstractClassHungarianPrefix`
52 - :option:`AggressiveDependentMemberLookup`
53 - :option:`CheckAnonFieldInParent`
54 - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix`, :option:`ClassIgnoredRegexp`, :option:`ClassHungarianPrefix`
55 - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`, :option:`ClassConstantSuffix`, :option:`ClassConstantIgnoredRegexp`, :option:`ClassConstantHungarianPrefix`
56 - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`, :option:`ClassMemberSuffix`, :option:`ClassMemberIgnoredRegexp`, :option:`ClassMemberHungarianPrefix`
57 - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`, :option:`ClassMethodSuffix`, :option:`ClassMethodIgnoredRegexp`
58 - :option:`ConceptCase`, :option:`ConceptPrefix`, :option:`ConceptSuffix`, :option:`ConceptIgnoredRegexp`
59 - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix`, :option:`ConstantIgnoredRegexp`, :option:`ConstantHungarianPrefix`
60 - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`, :option:`ConstantMemberSuffix`, :option:`ConstantMemberIgnoredRegexp`, :option:`ConstantMemberHungarianPrefix`
61 - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`, :option:`ConstantParameterSuffix`, :option:`ConstantParameterIgnoredRegexp`, :option:`ConstantParameterHungarianPrefix`
62 - :option:`ConstantPointerParameterCase`, :option:`ConstantPointerParameterPrefix`, :option:`ConstantPointerParameterSuffix`, :option:`ConstantPointerParameterIgnoredRegexp`, :option:`ConstantPointerParameterHungarianPrefix`
63 - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`, :option:`ConstexprFunctionSuffix`, :option:`ConstexprFunctionIgnoredRegexp`
64 - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`, :option:`ConstexprMethodSuffix`, :option:`ConstexprMethodIgnoredRegexp`
65 - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`, :option:`ConstexprVariableSuffix`, :option:`ConstexprVariableIgnoredRegexp`, :option:`ConstexprVariableHungarianPrefix`
66 - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix`, :option:`EnumIgnoredRegexp`
67 - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`, :option:`EnumConstantSuffix`, :option:`EnumConstantIgnoredRegexp`, :option:`EnumConstantHungarianPrefix`
68 - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix`, :option:`FunctionIgnoredRegexp`
69 - :option:`GetConfigPerFile`
70 - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix`, :option:`GlobalConstantIgnoredRegexp`, :option:`GlobalConstantHungarianPrefix`
71 - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix`, :option:`GlobalConstantPointerIgnoredRegexp`, :option:`GlobalConstantPointerHungarianPrefix`
72 - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`, :option:`GlobalFunctionSuffix`, :option:`GlobalFunctionIgnoredRegexp`
73 - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix`, :option:`GlobalPointerIgnoredRegexp`, :option:`GlobalPointerHungarianPrefix`
74 - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix`, :option:`GlobalVariableIgnoredRegexp`, :option:`GlobalVariableHungarianPrefix`
75 - :option:`IgnoreMainLikeFunctions`
76 - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`, :option:`InlineNamespaceSuffix`, :option:`InlineNamespaceIgnoredRegexp`
77 - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`, :option:`LocalConstantSuffix`, :option:`LocalConstantIgnoredRegexp`, :option:`LocalConstantHungarianPrefix`
78 - :option:`LocalConstantPointerCase`, :option:`LocalConstantPointerPrefix`, :option:`LocalConstantPointerSuffix`, :option:`LocalConstantPointerIgnoredRegexp`, :option:`LocalConstantPointerHungarianPrefix`
79 - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`, :option:`LocalPointerSuffix`, :option:`LocalPointerIgnoredRegexp`, :option:`LocalPointerHungarianPrefix`
80 - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`, :option:`LocalVariableSuffix`, :option:`LocalVariableIgnoredRegexp`, :option:`LocalVariableHungarianPrefix`
81 - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`, :option:`MacroDefinitionSuffix`, :option:`MacroDefinitionIgnoredRegexp`
82 - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`, :option:`MemberIgnoredRegexp`, :option:`MemberHungarianPrefix`
83 - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix`, :option:`MethodIgnoredRegexp`
84 - :option:`NamespaceCase`, :option:`NamespacePrefix`, :option:`NamespaceSuffix`, :option:`NamespaceIgnoredRegexp`
85 - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix`, :option:`ParameterIgnoredRegexp`, :option:`ParameterHungarianPrefix`
86 - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix`, :option:`ParameterPackIgnoredRegexp`
87 - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix`, :option:`PointerParameterIgnoredRegexp`, :option:`PointerParameterHungarianPrefix`
88 - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix`, :option:`PrivateMemberIgnoredRegexp`, :option:`PrivateMemberHungarianPrefix`
89 - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix`, :option:`PrivateMethodIgnoredRegexp`
90 - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix`, :option:`ProtectedMemberIgnoredRegexp`, :option:`ProtectedMemberHungarianPrefix`
91 - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix`, :option:`ProtectedMethodIgnoredRegexp`
92 - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix`, :option:`PublicMemberIgnoredRegexp`, :option:`PublicMemberHungarianPrefix`
93 - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`, :option:`PublicMethodSuffix`, :option:`PublicMethodIgnoredRegexp`
94 - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`, :option:`ScopedEnumConstantSuffix`, :option:`ScopedEnumConstantIgnoredRegexp`
95 - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix`, :option:`StaticConstantIgnoredRegexp`, :option:`StaticConstantHungarianPrefix`
96 - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix`, :option:`StaticVariableIgnoredRegexp`, :option:`StaticVariableHungarianPrefix`
97 - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix`, :option:`StructIgnoredRegexp`
98 - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`, :option:`TemplateParameterSuffix`, :option:`TemplateParameterIgnoredRegexp`
99 - :option:`TemplateTemplateParameterCase`, :option:`TemplateTemplateParameterPrefix`, :option:`TemplateTemplateParameterSuffix`, :option:`TemplateTemplateParameterIgnoredRegexp`
100 - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`, :option:`TypeAliasSuffix`, :option:`TypeAliasIgnoredRegexp`
101 - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix`, :option:`TypedefIgnoredRegexp`
102 - :option:`TypeTemplateParameterCase`, :option:`TypeTemplateParameterPrefix`, :option:`TypeTemplateParameterSuffix`, :option:`TypeTemplateParameterIgnoredRegexp`
103 - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix`, :option:`UnionIgnoredRegexp`
104 - :option:`ValueTemplateParameterCase`, :option:`ValueTemplateParameterPrefix`, :option:`ValueTemplateParameterSuffix`, :option:`ValueTemplateParameterIgnoredRegexp`
105 - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix`, :option:`VariableIgnoredRegexp`, :option:`VariableHungarianPrefix`
106 - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`, :option:`VirtualMethodSuffix`, :option:`VirtualMethodIgnoredRegexp`
107
108 .. option:: AbstractClassCase
109
110 When defined, the check will ensure abstract class names conform to the
111 selected casing.
112
113 .. option:: AbstractClassPrefix
114
115 When defined, the check will ensure abstract class names will add the
116 prefixed with the given value (regardless of casing).
117
118 .. option:: AbstractClassIgnoredRegexp
119
120 Identifier naming checks won't be enforced for abstract class names
121 matching this regular expression.
122
123 .. option:: AbstractClassSuffix
124
125 When defined, the check will ensure abstract class names will add the
126 suffix with the given value (regardless of casing).
127
128 .. option:: AbstractClassHungarianPrefix
129
130 When enabled, the check ensures that the declared identifier will
131 have a Hungarian notation prefix based on the declared type.
132
133 For example using values of:
134
135 - AbstractClassCase of ``lower_case``
136 - AbstractClassPrefix of ``pre_``
137 - AbstractClassSuffix of ``_post``
138 - AbstractClassHungarianPrefix of ``On``
139
140
141 Identifies and/or transforms abstract class names as follows:
142
143 Before:
144
145 .. code-block:: c++
146
147 class ABSTRACT_CLASS {
148 public:
149 ABSTRACT_CLASS();
150 };
151
152 After:
153
154 .. code-block:: c++
155
156 class pre_abstract_class_post {
157 public:
158 pre_abstract_class_post();
159 };
160
161 .. option:: AggressiveDependentMemberLookup
162
163 When set to `true` the check will look in dependent base classes for dependent
164 member references that need changing. This can lead to errors with template
165 specializations so the default value is `false`.
166
167 For example using values of:
168
169 - ClassMemberCase of ``lower_case``
170
171 Before:
172
173 .. code-block:: c++
174
175 template <typename T>
176 struct Base {
177 T BadNamedMember;
178 };
179
180 template <typename T>
181 struct Derived : Base<T> {
182 void reset() {
183 this->BadNamedMember = 0;
184 }
185 };
186
187 After if AggressiveDependentMemberLookup is `false`:
188
189 .. code-block:: c++
190
191 template <typename T>
192 struct Base {
193 T bad_named_member;
194 };
195
196 template <typename T>
197 struct Derived : Base<T> {
198 void reset() {
199 this->BadNamedMember = 0;
200 }
201 };
202
203 After if AggressiveDependentMemberLookup is `true`:
204
205 .. code-block:: c++
206
207 template <typename T>
208 struct Base {
209 T bad_named_member;
210 };
211
212 template <typename T>
213 struct Derived : Base<T> {
214 void reset() {
215 this->bad_named_member = 0;
216 }
217 };
218
219 .. option:: CheckAnonFieldInParent
220
221 When set to `true`, fields in anonymous records (i.e. anonymous
222 unions and structs) will be treated as names in the enclosing scope
223 rather than public members of the anonymous record for the purpose
224 of name checking.
225
226 For example:
227
228 .. code-block:: c++
229
230 class Foo {
231 private:
232 union {
233 int iv_;
234 float fv_;
235 };
236 };
237
238 If :option:`CheckAnonFieldInParent` is `false`, you may get warnings
239 that ``iv_`` and ``fv_`` are not coherent to public member names, because
240 ``iv_`` and ``fv_`` are public members of the anonymous union. When
241 :option:`CheckAnonFieldInParent` is `true`, ``iv_`` and ``fv_`` will be
242 treated as private data members of ``Foo`` for the purpose of name checking
243 and thus no warnings will be emitted.
244
245 .. option:: ClassCase
246
247 When defined, the check will ensure class names conform to the
248 selected casing.
249
250 .. option:: ClassPrefix
251
252 When defined, the check will ensure class names will add the
253 prefixed with the given value (regardless of casing).
254
255 .. option:: ClassIgnoredRegexp
256
257 Identifier naming checks won't be enforced for class names matching
258 this regular expression.
259
260 .. option:: ClassSuffix
261
262 When defined, the check will ensure class names will add the
263 suffix with the given value (regardless of casing).
264
265 .. option:: ClassHungarianPrefix
266
267 When enabled, the check ensures that the declared identifier will
268 have a Hungarian notation prefix based on the declared type.
269
270 For example using values of:
271
272 - ClassCase of ``lower_case``
273 - ClassPrefix of ``pre_``
274 - ClassSuffix of ``_post``
275 - ClassHungarianPrefix of ``On``
276
277 Identifies and/or transforms class names as follows:
278
279 Before:
280
281 .. code-block:: c++
282
283 class FOO {
284 public:
285 FOO();
286 ~FOO();
287 };
288
289 After:
290
291 .. code-block:: c++
292
293 class pre_foo_post {
294 public:
295 pre_foo_post();
296 ~pre_foo_post();
297 };
298
299 .. option:: ClassConstantCase
300
301 When defined, the check will ensure class constant names conform to the
302 selected casing.
303
304 .. option:: ClassConstantPrefix
305
306 When defined, the check will ensure class constant names will add the
307 prefixed with the given value (regardless of casing).
308
309 .. option:: ClassConstantIgnoredRegexp
310
311 Identifier naming checks won't be enforced for class constant names
312 matching this regular expression.
313
314 .. option:: ClassConstantSuffix
315
316 When defined, the check will ensure class constant names will add the
317 suffix with the given value (regardless of casing).
318
319 .. option:: ClassConstantHungarianPrefix
320
321 When enabled, the check ensures that the declared identifier will
322 have a Hungarian notation prefix based on the declared type.
323
324 For example using values of:
325
326 - ClassConstantCase of ``lower_case``
327 - ClassConstantPrefix of ``pre_``
328 - ClassConstantSuffix of ``_post``
329 - ClassConstantHungarianPrefix of ``On``
330
331 Identifies and/or transforms class constant names as follows:
332
333 Before:
334
335 .. code-block:: c++
336
337 class FOO {
338 public:
339 static const int CLASS_CONSTANT;
340 };
341
342 After:
343
344 .. code-block:: c++
345
346 class FOO {
347 public:
348 static const int pre_class_constant_post;
349 };
350
351 .. option:: ClassMemberCase
352
353 When defined, the check will ensure class member names conform to the
354 selected casing.
355
356 .. option:: ClassMemberPrefix
357
358 When defined, the check will ensure class member names will add the
359 prefixed with the given value (regardless of casing).
360
361 .. option:: ClassMemberIgnoredRegexp
362
363 Identifier naming checks won't be enforced for class member names
364 matching this regular expression.
365
366 .. option:: ClassMemberSuffix
367
368 When defined, the check will ensure class member names will add the
369 suffix with the given value (regardless of casing).
370
371 .. option:: ClassMemberHungarianPrefix
372
373 When enabled, the check ensures that the declared identifier will
374 have a Hungarian notation prefix based on the declared type.
375
376 For example using values of:
377
378 - ClassMemberCase of ``lower_case``
379 - ClassMemberPrefix of ``pre_``
380 - ClassMemberSuffix of ``_post``
381 - ClassMemberHungarianPrefix of ``On``
382
383 Identifies and/or transforms class member names as follows:
384
385 Before:
386
387 .. code-block:: c++
388
389 class FOO {
390 public:
391 static int CLASS_CONSTANT;
392 };
393
394 After:
395
396 .. code-block:: c++
397
398 class FOO {
399 public:
400 static int pre_class_constant_post;
401 };
402
403 .. option:: ClassMethodCase
404
405 When defined, the check will ensure class method names conform to the
406 selected casing.
407
408 .. option:: ClassMethodPrefix
409
410 When defined, the check will ensure class method names will add the
411 prefixed with the given value (regardless of casing).
412
413 .. option:: ClassMethodIgnoredRegexp
414
415 Identifier naming checks won't be enforced for class method names
416 matching this regular expression.
417
418 .. option:: ClassMethodSuffix
419
420 When defined, the check will ensure class method names will add the
421 suffix with the given value (regardless of casing).
422
423 For example using values of:
424
425 - ClassMethodCase of ``lower_case``
426 - ClassMethodPrefix of ``pre_``
427 - ClassMethodSuffix of ``_post``
428
429 Identifies and/or transforms class method names as follows:
430
431 Before:
432
433 .. code-block:: c++
434
435 class FOO {
436 public:
437 int CLASS_MEMBER();
438 };
439
440 After:
441
442 .. code-block:: c++
443
444 class FOO {
445 public:
446 int pre_class_member_post();
447 };
448
449 .. option:: ConceptCase
450
451 When defined, the check will ensure concept names conform to the
452 selected casing.
453
454 .. option:: ConceptPrefix
455
456 When defined, the check will ensure concept names will add the
457 prefixed with the given value (regardless of casing).
458
459 .. option:: ConceptIgnoredRegexp
460
461 Identifier naming checks won't be enforced for concept names
462 matching this regular expression.
463
464 .. option:: ConceptSuffix
465
466 When defined, the check will ensure concept names will add the
467 suffix with the given value (regardless of casing).
468
469 For example using values of:
470
471 - ConceptCase of ``CamelCase``
472 - ConceptPrefix of ``Pre``
473 - ConceptSuffix of ``Post``
474
475 Identifies and/or transforms concept names as follows:
476
477 Before:
478
479 .. code-block:: c++
480
481 template<typename T> concept my_concept = requires (T t) { {t++}; };
482
483 After:
484
485 .. code-block:: c++
486
487 template<typename T> concept PreMyConceptPost = requires (T t) { {t++}; };
488
489 .. option:: ConstantCase
490
491 When defined, the check will ensure constant names conform to the
492 selected casing.
493
494 .. option:: ConstantPrefix
495
496 When defined, the check will ensure constant names will add the
497 prefixed with the given value (regardless of casing).
498
499 .. option:: ConstantIgnoredRegexp
500
501 Identifier naming checks won't be enforced for constant names
502 matching this regular expression.
503
504 .. option:: ConstantSuffix
505
506 When defined, the check will ensure constant names will add the
507 suffix with the given value (regardless of casing).
508
509 .. option:: ConstantHungarianPrefix
510
511 When enabled, the check ensures that the declared identifier will
512 have a Hungarian notation prefix based on the declared type.
513
514 For example using values of:
515
516 - ConstantCase of ``lower_case``
517 - ConstantPrefix of ``pre_``
518 - ConstantSuffix of ``_post``
519 - ConstantHungarianPrefix of ``On``
520
521 Identifies and/or transforms constant names as follows:
522
523 Before:
524
525 .. code-block:: c++
526
527 void function() { unsigned const MyConst_array[] = {1, 2, 3}; }
528
529 After:
530
531 .. code-block:: c++
532
533 void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }
534
535 .. option:: ConstantMemberCase
536
537 When defined, the check will ensure constant member names conform to the
538 selected casing.
539
540 .. option:: ConstantMemberPrefix
541
542 When defined, the check will ensure constant member names will add the
543 prefixed with the given value (regardless of casing).
544
545 .. option:: ConstantMemberIgnoredRegexp
546
547 Identifier naming checks won't be enforced for constant member names
548 matching this regular expression.
549
550 .. option:: ConstantMemberSuffix
551
552 When defined, the check will ensure constant member names will add the
553 suffix with the given value (regardless of casing).
554
555 .. option:: ConstantMemberHungarianPrefix
556
557 When enabled, the check ensures that the declared identifier will
558 have a Hungarian notation prefix based on the declared type.
559
560 For example using values of:
561
562 - ConstantMemberCase of ``lower_case``
563 - ConstantMemberPrefix of ``pre_``
564 - ConstantMemberSuffix of ``_post``
565 - ConstantMemberHungarianPrefix of ``On``
566
567 Identifies and/or transforms constant member names as follows:
568
569 Before:
570
571 .. code-block:: c++
572
573 class Foo {
574 char const MY_ConstMember_string[4] = "123";
575 }
576
577 After:
578
579 .. code-block:: c++
580
581 class Foo {
582 char const pre_my_constmember_string_post[4] = "123";
583 }
584
585 .. option:: ConstantParameterCase
586
587 When defined, the check will ensure constant parameter names conform to the
588 selected casing.
589
590 .. option:: ConstantParameterPrefix
591
592 When defined, the check will ensure constant parameter names will add the
593 prefixed with the given value (regardless of casing).
594
595 .. option:: ConstantParameterIgnoredRegexp
596
597 Identifier naming checks won't be enforced for constant parameter names
598 matching this regular expression.
599
600 .. option:: ConstantParameterSuffix
601
602 When defined, the check will ensure constant parameter names will add the
603 suffix with the given value (regardless of casing).
604
605 .. option:: ConstantParameterHungarianPrefix
606
607 When enabled, the check ensures that the declared identifier will
608 have a Hungarian notation prefix based on the declared type.
609
610 For example using values of:
611
612 - ConstantParameterCase of ``lower_case``
613 - ConstantParameterPrefix of ``pre_``
614 - ConstantParameterSuffix of ``_post``
615 - ConstantParameterHungarianPrefix of ``On``
616
617 Identifies and/or transforms constant parameter names as follows:
618
619 Before:
620
621 .. code-block:: c++
622
623 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
624
625 After:
626
627 .. code-block:: c++
628
629 void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);
630
631 .. option:: ConstantPointerParameterCase
632
633 When defined, the check will ensure constant pointer parameter names conform to the
634 selected casing.
635
636 .. option:: ConstantPointerParameterPrefix
637
638 When defined, the check will ensure constant pointer parameter names will add the
639 prefixed with the given value (regardless of casing).
640
641 .. option:: ConstantPointerParameterIgnoredRegexp
642
643 Identifier naming checks won't be enforced for constant pointer parameter
644 names matching this regular expression.
645
646 .. option:: ConstantPointerParameterSuffix
647
648 When defined, the check will ensure constant pointer parameter names will add the
649 suffix with the given value (regardless of casing).
650
651 .. option:: ConstantPointerParameterHungarianPrefix
652
653 When enabled, the check ensures that the declared identifier will
654 have a Hungarian notation prefix based on the declared type.
655
656 For example using values of:
657
658 - ConstantPointerParameterCase of ``lower_case``
659 - ConstantPointerParameterPrefix of ``pre_``
660 - ConstantPointerParameterSuffix of ``_post``
661 - ConstantPointerParameterHungarianPrefix of ``On``
662
663 Identifies and/or transforms constant pointer parameter names as follows:
664
665 Before:
666
667 .. code-block:: c++
668
669 void GLOBAL_FUNCTION(int const *CONST_parameter);
670
671 After:
672
673 .. code-block:: c++
674
675 void GLOBAL_FUNCTION(int const *pre_const_parameter_post);
676
677 .. option:: ConstexprFunctionCase
678
679 When defined, the check will ensure constexpr function names conform to the
680 selected casing.
681
682 .. option:: ConstexprFunctionPrefix
683
684 When defined, the check will ensure constexpr function names will add the
685 prefixed with the given value (regardless of casing).
686
687 .. option:: ConstexprFunctionIgnoredRegexp
688
689 Identifier naming checks won't be enforced for constexpr function names
690 matching this regular expression.
691
692 .. option:: ConstexprFunctionSuffix
693
694 When defined, the check will ensure constexpr function names will add the
695 suffix with the given value (regardless of casing).
696
697 For example using values of:
698
699 - ConstexprFunctionCase of ``lower_case``
700 - ConstexprFunctionPrefix of ``pre_``
701 - ConstexprFunctionSuffix of ``_post``
702
703 Identifies and/or transforms constexpr function names as follows:
704
705 Before:
706
707 .. code-block:: c++
708
709 constexpr int CE_function() { return 3; }
710
711 After:
712
713 .. code-block:: c++
714
715 constexpr int pre_ce_function_post() { return 3; }
716
717 .. option:: ConstexprMethodCase
718
719 When defined, the check will ensure constexpr method names conform to the
720 selected casing.
721
722 .. option:: ConstexprMethodPrefix
723
724 When defined, the check will ensure constexpr method names will add the
725 prefixed with the given value (regardless of casing).
726
727 .. option:: ConstexprMethodIgnoredRegexp
728
729 Identifier naming checks won't be enforced for constexpr method names
730 matching this regular expression.
731
732 .. option:: ConstexprMethodSuffix
733
734 When defined, the check will ensure constexpr method names will add the
735 suffix with the given value (regardless of casing).
736
737 For example using values of:
738
739 - ConstexprMethodCase of ``lower_case``
740 - ConstexprMethodPrefix of ``pre_``
741 - ConstexprMethodSuffix of ``_post``
742
743 Identifies and/or transforms constexpr method names as follows:
744
745 Before:
746
747 .. code-block:: c++
748
749 class Foo {
750 public:
751 constexpr int CST_expr_Method() { return 2; }
752 }
753
754 After:
755
756 .. code-block:: c++
757
758 class Foo {
759 public:
760 constexpr int pre_cst_expr_method_post() { return 2; }
761 }
762
763 .. option:: ConstexprVariableCase
764
765 When defined, the check will ensure constexpr variable names conform to the
766 selected casing.
767
768 .. option:: ConstexprVariablePrefix
769
770 When defined, the check will ensure constexpr variable names will add the
771 prefixed with the given value (regardless of casing).
772
773 .. option:: ConstexprVariableIgnoredRegexp
774
775 Identifier naming checks won't be enforced for constexpr variable names
776 matching this regular expression.
777
778 .. option:: ConstexprVariableSuffix
779
780 When defined, the check will ensure constexpr variable names will add the
781 suffix with the given value (regardless of casing).
782
783 .. option:: ConstexprVariableHungarianPrefix
784
785 When enabled, the check ensures that the declared identifier will
786 have a Hungarian notation prefix based on the declared type.
787
788 For example using values of:
789
790 - ConstexprVariableCase of ``lower_case``
791 - ConstexprVariablePrefix of ``pre_``
792 - ConstexprVariableSuffix of ``_post``
793 - ConstexprVariableHungarianPrefix of ``On``
794
795 Identifies and/or transforms constexpr variable names as follows:
796
797 Before:
798
799 .. code-block:: c++
800
801 constexpr int ConstExpr_variable = MyConstant;
802
803 After:
804
805 .. code-block:: c++
806
807 constexpr int pre_constexpr_variable_post = MyConstant;
808
809 .. option:: EnumCase
810
811 When defined, the check will ensure enumeration names conform to the
812 selected casing.
813
814 .. option:: EnumPrefix
815
816 When defined, the check will ensure enumeration names will add the
817 prefixed with the given value (regardless of casing).
818
819 .. option:: EnumIgnoredRegexp
820
821 Identifier naming checks won't be enforced for enumeration names
822 matching this regular expression.
823
824 .. option:: EnumSuffix
825
826 When defined, the check will ensure enumeration names will add the
827 suffix with the given value (regardless of casing).
828
829 For example using values of:
830
831 - EnumCase of ``lower_case``
832 - EnumPrefix of ``pre_``
833 - EnumSuffix of ``_post``
834
835 Identifies and/or transforms enumeration names as follows:
836
837 Before:
838
839 .. code-block:: c++
840
841 enum FOO { One, Two, Three };
842
843 After:
844
845 .. code-block:: c++
846
847 enum pre_foo_post { One, Two, Three };
848
849 .. option:: EnumConstantCase
850
851 When defined, the check will ensure enumeration constant names conform to the
852 selected casing.
853
854 .. option:: EnumConstantPrefix
855
856 When defined, the check will ensure enumeration constant names will add the
857 prefixed with the given value (regardless of casing).
858
859 .. option:: EnumConstantIgnoredRegexp
860
861 Identifier naming checks won't be enforced for enumeration constant names
862 matching this regular expression.
863
864 .. option:: EnumConstantSuffix
865
866 When defined, the check will ensure enumeration constant names will add the
867 suffix with the given value (regardless of casing).
868
869 .. option:: EnumConstantHungarianPrefix
870
871 When enabled, the check ensures that the declared identifier will
872 have a Hungarian notation prefix based on the declared type.
873
874 For example using values of:
875
876 - EnumConstantCase of ``lower_case``
877 - EnumConstantPrefix of ``pre_``
878 - EnumConstantSuffix of ``_post``
879 - EnumConstantHungarianPrefix of ``On``
880
881 Identifies and/or transforms enumeration constant names as follows:
882
883 Before:
884
885 .. code-block:: c++
886
887 enum FOO { One, Two, Three };
888
889 After:
890
891 .. code-block:: c++
892
893 enum FOO { pre_One_post, pre_Two_post, pre_Three_post };
894
895 .. option:: FunctionCase
896
897 When defined, the check will ensure function names conform to the
898 selected casing.
899
900 .. option:: FunctionPrefix
901
902 When defined, the check will ensure function names will add the
903 prefixed with the given value (regardless of casing).
904
905 .. option:: FunctionIgnoredRegexp
906
907 Identifier naming checks won't be enforced for function names
908 matching this regular expression.
909
910 .. option:: FunctionSuffix
911
912 When defined, the check will ensure function names will add the
913 suffix with the given value (regardless of casing).
914
915 For example using values of:
916
917 - FunctionCase of ``lower_case``
918 - FunctionPrefix of ``pre_``
919 - FunctionSuffix of ``_post``
920
921 Identifies and/or transforms function names as follows:
922
923 Before:
924
925 .. code-block:: c++
926
927 char MY_Function_string();
928
929 After:
930
931 .. code-block:: c++
932
933 char pre_my_function_string_post();
934
935 .. option:: GetConfigPerFile
936
937 When `true` the check will look for the configuration for where an
938 identifier is declared. Useful for when included header files use a
939 different style.
940 Default value is `true`.
941
942 .. option:: GlobalConstantCase
943
944 When defined, the check will ensure global constant names conform to the
945 selected casing.
946
947 .. option:: GlobalConstantPrefix
948
949 When defined, the check will ensure global constant names will add the
950 prefixed with the given value (regardless of casing).
951
952 .. option:: GlobalConstantIgnoredRegexp
953
954 Identifier naming checks won't be enforced for global constant names
955 matching this regular expression.
956
957 .. option:: GlobalConstantSuffix
958
959 When defined, the check will ensure global constant names will add the
960 suffix with the given value (regardless of casing).
961
962 .. option:: GlobalConstantHungarianPrefix
963
964 When enabled, the check ensures that the declared identifier will
965 have a Hungarian notation prefix based on the declared type.
966
967 For example using values of:
968
969 - GlobalConstantCase of ``lower_case``
970 - GlobalConstantPrefix of ``pre_``
971 - GlobalConstantSuffix of ``_post``
972 - GlobalConstantHungarianPrefix of ``On``
973
974 Identifies and/or transforms global constant names as follows:
975
976 Before:
977
978 .. code-block:: c++
979
980 unsigned const MyConstGlobal_array[] = {1, 2, 3};
981
982 After:
983
984 .. code-block:: c++
985
986 unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};
987
988 .. option:: GlobalConstantPointerCase
989
990 When defined, the check will ensure global constant pointer names conform to the
991 selected casing.
992
993 .. option:: GlobalConstantPointerPrefix
994
995 When defined, the check will ensure global constant pointer names will add the
996 prefixed with the given value (regardless of casing).
997
998 .. option:: GlobalConstantPointerIgnoredRegexp
999
1000 Identifier naming checks won't be enforced for global constant pointer
1001 names matching this regular expression.
1002
1003 .. option:: GlobalConstantPointerSuffix
1004
1005 When defined, the check will ensure global constant pointer names will add the
1006 suffix with the given value (regardless of casing).
1007
1008 .. option:: GlobalConstantPointerHungarianPrefix
1009
1010 When enabled, the check ensures that the declared identifier will
1011 have a Hungarian notation prefix based on the declared type.
1012
1013 For example using values of:
1014
1015 - GlobalConstantPointerCase of ``lower_case``
1016 - GlobalConstantPointerPrefix of ``pre_``
1017 - GlobalConstantPointerSuffix of ``_post``
1018 - GlobalConstantPointerHungarianPrefix of ``On``
1019
1020 Identifies and/or transforms global constant pointer names as follows:
1021
1022 Before:
1023
1024 .. code-block:: c++
1025
1026 int *const MyConstantGlobalPointer = nullptr;
1027
1028 After:
1029
1030 .. code-block:: c++
1031
1032 int *const pre_myconstantglobalpointer_post = nullptr;
1033
1034 .. option:: GlobalFunctionCase
1035
1036 When defined, the check will ensure global function names conform to the
1037 selected casing.
1038
1039 .. option:: GlobalFunctionPrefix
1040
1041 When defined, the check will ensure global function names will add the
1042 prefixed with the given value (regardless of casing).
1043
1044 .. option:: GlobalFunctionIgnoredRegexp
1045
1046 Identifier naming checks won't be enforced for global function names
1047 matching this regular expression.
1048
1049 .. option:: GlobalFunctionSuffix
1050
1051 When defined, the check will ensure global function names will add the
1052 suffix with the given value (regardless of casing).
1053
1054 For example using values of:
1055
1056 - GlobalFunctionCase of ``lower_case``
1057 - GlobalFunctionPrefix of ``pre_``
1058 - GlobalFunctionSuffix of ``_post``
1059
1060 Identifies and/or transforms global function names as follows:
1061
1062 Before:
1063
1064 .. code-block:: c++
1065
1066 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
1067
1068 After:
1069
1070 .. code-block:: c++
1071
1072 void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);
1073
1074 .. option:: GlobalPointerCase
1075
1076 When defined, the check will ensure global pointer names conform to the
1077 selected casing.
1078
1079 .. option:: GlobalPointerPrefix
1080
1081 When defined, the check will ensure global pointer names will add the
1082 prefixed with the given value (regardless of casing).
1083
1084 .. option:: GlobalPointerIgnoredRegexp
1085
1086 Identifier naming checks won't be enforced for global pointer names
1087 matching this regular expression.
1088
1089 .. option:: GlobalPointerSuffix
1090
1091 When defined, the check will ensure global pointer names will add the
1092 suffix with the given value (regardless of casing).
1093
1094 .. option:: GlobalPointerHungarianPrefix
1095
1096 When enabled, the check ensures that the declared identifier will
1097 have a Hungarian notation prefix based on the declared type.
1098
1099 For example using values of:
1100
1101 - GlobalPointerCase of ``lower_case``
1102 - GlobalPointerPrefix of ``pre_``
1103 - GlobalPointerSuffix of ``_post``
1104 - GlobalPointerHungarianPrefix of ``On``
1105
1106 Identifies and/or transforms global pointer names as follows:
1107
1108 Before:
1109
1110 .. code-block:: c++
1111
1112 int *GLOBAL3;
1113
1114 After:
1115
1116 .. code-block:: c++
1117
1118 int *pre_global3_post;
1119
1120 .. option:: GlobalVariableCase
1121
1122 When defined, the check will ensure global variable names conform to the
1123 selected casing.
1124
1125 .. option:: GlobalVariablePrefix
1126
1127 When defined, the check will ensure global variable names will add the
1128 prefixed with the given value (regardless of casing).
1129
1130 .. option:: GlobalVariableIgnoredRegexp
1131
1132 Identifier naming checks won't be enforced for global variable names
1133 matching this regular expression.
1134
1135 .. option:: GlobalVariableSuffix
1136
1137 When defined, the check will ensure global variable names will add the
1138 suffix with the given value (regardless of casing).
1139
1140 .. option:: GlobalVariableHungarianPrefix
1141
1142 When enabled, the check ensures that the declared identifier will
1143 have a Hungarian notation prefix based on the declared type.
1144
1145 For example using values of:
1146
1147 - GlobalVariableCase of ``lower_case``
1148 - GlobalVariablePrefix of ``pre_``
1149 - GlobalVariableSuffix of ``_post``
1150 - GlobalVariableHungarianPrefix of ``On``
1151
1152 Identifies and/or transforms global variable names as follows:
1153
1154 Before:
1155
1156 .. code-block:: c++
1157
1158 int GLOBAL3;
1159
1160 After:
1161
1162 .. code-block:: c++
1163
1164 int pre_global3_post;
1165
1166 .. option:: IgnoreMainLikeFunctions
1167
1168 When set to `true` functions that have a similar signature to ``main`` or
1169 ``wmain`` won't enforce checks on the names of their parameters.
1170 Default value is `false`.
1171
1172 .. option:: InlineNamespaceCase
1173
1174 When defined, the check will ensure inline namespaces names conform to the
1175 selected casing.
1176
1177 .. option:: InlineNamespacePrefix
1178
1179 When defined, the check will ensure inline namespaces names will add the
1180 prefixed with the given value (regardless of casing).
1181
1182 .. option:: InlineNamespaceIgnoredRegexp
1183
1184 Identifier naming checks won't be enforced for inline namespaces names
1185 matching this regular expression.
1186
1187 .. option:: InlineNamespaceSuffix
1188
1189 When defined, the check will ensure inline namespaces names will add the
1190 suffix with the given value (regardless of casing).
1191
1192 For example using values of:
1193
1194 - InlineNamespaceCase of ``lower_case``
1195 - InlineNamespacePrefix of ``pre_``
1196 - InlineNamespaceSuffix of ``_post``
1197
1198 Identifies and/or transforms inline namespaces names as follows:
1199
1200 Before:
1201
1202 .. code-block:: c++
1203
1204 namespace FOO_NS {
1205 inline namespace InlineNamespace {
1206 ...
1207 }
1208 } // namespace FOO_NS
1209
1210 After:
1211
1212 .. code-block:: c++
1213
1214 namespace FOO_NS {
1215 inline namespace pre_inlinenamespace_post {
1216 ...
1217 }
1218 } // namespace FOO_NS
1219
1220 .. option:: LocalConstantCase
1221
1222 When defined, the check will ensure local constant names conform to the
1223 selected casing.
1224
1225 .. option:: LocalConstantPrefix
1226
1227 When defined, the check will ensure local constant names will add the
1228 prefixed with the given value (regardless of casing).
1229
1230 .. option:: LocalConstantIgnoredRegexp
1231
1232 Identifier naming checks won't be enforced for local constant names
1233 matching this regular expression.
1234
1235 .. option:: LocalConstantSuffix
1236
1237 When defined, the check will ensure local constant names will add the
1238 suffix with the given value (regardless of casing).
1239
1240 .. option:: LocalConstantHungarianPrefix
1241
1242 When enabled, the check ensures that the declared identifier will
1243 have a Hungarian notation prefix based on the declared type.
1244
1245 For example using values of:
1246
1247 - LocalConstantCase of ``lower_case``
1248 - LocalConstantPrefix of ``pre_``
1249 - LocalConstantSuffix of ``_post``
1250 - LocalConstantHungarianPrefix of ``On``
1251
1252 Identifies and/or transforms local constant names as follows:
1253
1254 Before:
1255
1256 .. code-block:: c++
1257
1258 void foo() { int const local_Constant = 3; }
1259
1260 After:
1261
1262 .. code-block:: c++
1263
1264 void foo() { int const pre_local_constant_post = 3; }
1265
1266 .. option:: LocalConstantPointerCase
1267
1268 When defined, the check will ensure local constant pointer names conform to the
1269 selected casing.
1270
1271 .. option:: LocalConstantPointerPrefix
1272
1273 When defined, the check will ensure local constant pointer names will add the
1274 prefixed with the given value (regardless of casing).
1275
1276 .. option:: LocalConstantPointerIgnoredRegexp
1277
1278 Identifier naming checks won't be enforced for local constant pointer names
1279 matching this regular expression.
1280
1281 .. option:: LocalConstantPointerSuffix
1282
1283 When defined, the check will ensure local constant pointer names will add the
1284 suffix with the given value (regardless of casing).
1285
1286 .. option:: LocalConstantPointerHungarianPrefix
1287
1288 When enabled, the check ensures that the declared identifier will
1289 have a Hungarian notation prefix based on the declared type.
1290
1291 For example using values of:
1292
1293 - LocalConstantPointerCase of ``lower_case``
1294 - LocalConstantPointerPrefix of ``pre_``
1295 - LocalConstantPointerSuffix of ``_post``
1296 - LocalConstantPointerHungarianPrefix of ``On``
1297
1298 Identifies and/or transforms local constant pointer names as follows:
1299
1300 Before:
1301
1302 .. code-block:: c++
1303
1304 void foo() { int const *local_Constant = 3; }
1305
1306 After:
1307
1308 .. code-block:: c++
1309
1310 void foo() { int const *pre_local_constant_post = 3; }
1311
1312 .. option:: LocalPointerCase
1313
1314 When defined, the check will ensure local pointer names conform to the
1315 selected casing.
1316
1317 .. option:: LocalPointerPrefix
1318
1319 When defined, the check will ensure local pointer names will add the
1320 prefixed with the given value (regardless of casing).
1321
1322 .. option:: LocalPointerIgnoredRegexp
1323
1324 Identifier naming checks won't be enforced for local pointer names
1325 matching this regular expression.
1326
1327 .. option:: LocalPointerSuffix
1328
1329 When defined, the check will ensure local pointer names will add the
1330 suffix with the given value (regardless of casing).
1331
1332 .. option:: LocalPointerHungarianPrefix
1333
1334 When enabled, the check ensures that the declared identifier will
1335 have a Hungarian notation prefix based on the declared type.
1336
1337 For example using values of:
1338
1339 - LocalPointerCase of ``lower_case``
1340 - LocalPointerPrefix of ``pre_``
1341 - LocalPointerSuffix of ``_post``
1342 - LocalPointerHungarianPrefix of ``On``
1343
1344 Identifies and/or transforms local pointer names as follows:
1345
1346 Before:
1347
1348 .. code-block:: c++
1349
1350 void foo() { int *local_Constant; }
1351
1352 After:
1353
1354 .. code-block:: c++
1355
1356 void foo() { int *pre_local_constant_post; }
1357
1358 .. option:: LocalVariableCase
1359
1360 When defined, the check will ensure local variable names conform to the
1361 selected casing.
1362
1363 .. option:: LocalVariablePrefix
1364
1365 When defined, the check will ensure local variable names will add the
1366 prefixed with the given value (regardless of casing).
1367
1368 .. option:: LocalVariableIgnoredRegexp
1369
1370 Identifier naming checks won't be enforced for local variable names
1371 matching this regular expression.
1372
1373 For example using values of:
1374
1375 - LocalVariableCase of ``CamelCase``
1376 - LocalVariableIgnoredRegexp of ``\w{1,2}``
1377
1378 Will exclude variables with a length less than or equal to 2 from the
1379 camel case check applied to other variables.
1380
1381 .. option:: LocalVariableSuffix
1382
1383 When defined, the check will ensure local variable names will add the
1384 suffix with the given value (regardless of casing).
1385
1386 .. option:: LocalVariableHungarianPrefix
1387
1388 When enabled, the check ensures that the declared identifier will
1389 have a Hungarian notation prefix based on the declared type.
1390
1391 For example using values of:
1392
1393 - LocalVariableCase of ``lower_case``
1394 - LocalVariablePrefix of ``pre_``
1395 - LocalVariableSuffix of ``_post``
1396 - LocalVariableHungarianPrefix of ``On``
1397
1398 Identifies and/or transforms local variable names as follows:
1399
1400 Before:
1401
1402 .. code-block:: c++
1403
1404 void foo() { int local_Constant; }
1405
1406 After:
1407
1408 .. code-block:: c++
1409
1410 void foo() { int pre_local_constant_post; }
1411
1412 .. option:: MacroDefinitionCase
1413
1414 When defined, the check will ensure macro definitions conform to the
1415 selected casing.
1416
1417 .. option:: MacroDefinitionPrefix
1418
1419 When defined, the check will ensure macro definitions will add the
1420 prefixed with the given value (regardless of casing).
1421
1422 .. option:: MacroDefinitionIgnoredRegexp
1423
1424 Identifier naming checks won't be enforced for macro definitions
1425 matching this regular expression.
1426
1427 .. option:: MacroDefinitionSuffix
1428
1429 When defined, the check will ensure macro definitions will add the
1430 suffix with the given value (regardless of casing).
1431
1432 For example using values of:
1433
1434 - MacroDefinitionCase of ``lower_case``
1435 - MacroDefinitionPrefix of ``pre_``
1436 - MacroDefinitionSuffix of ``_post``
1437
1438 Identifies and/or transforms macro definitions as follows:
1439
1440 Before:
1441
1442 .. code-block:: c
1443
1444 #define MY_MacroDefinition
1445
1446 After:
1447
1448 .. code-block:: c
1449
1450 #define pre_my_macro_definition_post
1451
1452 Note: This will not warn on builtin macros or macros defined on the command line
1453 using the ``-D`` flag.
1454
1455 .. option:: MemberCase
1456
1457 When defined, the check will ensure member names conform to the
1458 selected casing.
1459
1460 .. option:: MemberPrefix
1461
1462 When defined, the check will ensure member names will add the
1463 prefixed with the given value (regardless of casing).
1464
1465 .. option:: MemberIgnoredRegexp
1466
1467 Identifier naming checks won't be enforced for member names
1468 matching this regular expression.
1469
1470 .. option:: MemberSuffix
1471
1472 When defined, the check will ensure member names will add the
1473 suffix with the given value (regardless of casing).
1474
1475 .. option:: MemberHungarianPrefix
1476
1477 When enabled, the check ensures that the declared identifier will
1478 have a Hungarian notation prefix based on the declared type.
1479
1480 For example using values of:
1481
1482 - MemberCase of ``lower_case``
1483 - MemberPrefix of ``pre_``
1484 - MemberSuffix of ``_post``
1485 - MemberHungarianPrefix of ``On``
1486
1487 Identifies and/or transforms member names as follows:
1488
1489 Before:
1490
1491 .. code-block:: c++
1492
1493 class Foo {
1494 char MY_ConstMember_string[4];
1495 }
1496
1497 After:
1498
1499 .. code-block:: c++
1500
1501 class Foo {
1502 char pre_my_constmember_string_post[4];
1503 }
1504
1505 .. option:: MethodCase
1506
1507 When defined, the check will ensure method names conform to the
1508 selected casing.
1509
1510 .. option:: MethodPrefix
1511
1512 When defined, the check will ensure method names will add the
1513 prefixed with the given value (regardless of casing).
1514
1515 .. option:: MethodIgnoredRegexp
1516
1517 Identifier naming checks won't be enforced for method names
1518 matching this regular expression.
1519
1520 .. option:: MethodSuffix
1521
1522 When defined, the check will ensure method names will add the
1523 suffix with the given value (regardless of casing).
1524
1525 For example using values of:
1526
1527 - MethodCase of ``lower_case``
1528 - MethodPrefix of ``pre_``
1529 - MethodSuffix of ``_post``
1530
1531 Identifies and/or transforms method names as follows:
1532
1533 Before:
1534
1535 .. code-block:: c++
1536
1537 class Foo {
1538 char MY_Method_string();
1539 }
1540
1541 After:
1542
1543 .. code-block:: c++
1544
1545 class Foo {
1546 char pre_my_method_string_post();
1547 }
1548
1549 .. option:: NamespaceCase
1550
1551 When defined, the check will ensure namespace names conform to the
1552 selected casing.
1553
1554 .. option:: NamespacePrefix
1555
1556 When defined, the check will ensure namespace names will add the
1557 prefixed with the given value (regardless of casing).
1558
1559 .. option:: NamespaceIgnoredRegexp
1560
1561 Identifier naming checks won't be enforced for namespace names
1562 matching this regular expression.
1563
1564 .. option:: NamespaceSuffix
1565
1566 When defined, the check will ensure namespace names will add the
1567 suffix with the given value (regardless of casing).
1568
1569 For example using values of:
1570
1571 - NamespaceCase of ``lower_case``
1572 - NamespacePrefix of ``pre_``
1573 - NamespaceSuffix of ``_post``
1574
1575 Identifies and/or transforms namespace names as follows:
1576
1577 Before:
1578
1579 .. code-block:: c++
1580
1581 namespace FOO_NS {
1582 ...
1583 }
1584
1585 After:
1586
1587 .. code-block:: c++
1588
1589 namespace pre_foo_ns_post {
1590 ...
1591 }
1592
1593 .. option:: ParameterCase
1594
1595 When defined, the check will ensure parameter names conform to the
1596 selected casing.
1597
1598 .. option:: ParameterPrefix
1599
1600 When defined, the check will ensure parameter names will add the
1601 prefixed with the given value (regardless of casing).
1602
1603 .. option:: ParameterIgnoredRegexp
1604
1605 Identifier naming checks won't be enforced for parameter names
1606 matching this regular expression.
1607
1608 .. option:: ParameterSuffix
1609
1610 When defined, the check will ensure parameter names will add the
1611 suffix with the given value (regardless of casing).
1612
1613 .. option:: ParameterHungarianPrefix
1614
1615 When enabled, the check ensures that the declared identifier will
1616 have a Hungarian notation prefix based on the declared type.
1617
1618 For example using values of:
1619
1620 - ParameterCase of ``lower_case``
1621 - ParameterPrefix of ``pre_``
1622 - ParameterSuffix of ``_post``
1623 - ParameterHungarianPrefix of ``On``
1624
1625 Identifies and/or transforms parameter names as follows:
1626
1627 Before:
1628
1629 .. code-block:: c++
1630
1631 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
1632
1633 After:
1634
1635 .. code-block:: c++
1636
1637 void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);
1638
1639 .. option:: ParameterPackCase
1640
1641 When defined, the check will ensure parameter pack names conform to the
1642 selected casing.
1643
1644 .. option:: ParameterPackPrefix
1645
1646 When defined, the check will ensure parameter pack names will add the
1647 prefixed with the given value (regardless of casing).
1648
1649 .. option:: ParameterPackIgnoredRegexp
1650
1651 Identifier naming checks won't be enforced for parameter pack names
1652 matching this regular expression.
1653
1654 .. option:: ParameterPackSuffix
1655
1656 When defined, the check will ensure parameter pack names will add the
1657 suffix with the given value (regardless of casing).
1658
1659 For example using values of:
1660
1661 - ParameterPackCase of ``lower_case``
1662 - ParameterPackPrefix of ``pre_``
1663 - ParameterPackSuffix of ``_post``
1664
1665 Identifies and/or transforms parameter pack names as follows:
1666
1667 Before:
1668
1669 .. code-block:: c++
1670
1671 template <typename... TYPE_parameters> {
1672 void FUNCTION(int... TYPE_parameters);
1673 }
1674
1675 After:
1676
1677 .. code-block:: c++
1678
1679 template <typename... TYPE_parameters> {
1680 void FUNCTION(int... pre_type_parameters_post);
1681 }
1682
1683 .. option:: PointerParameterCase
1684
1685 When defined, the check will ensure pointer parameter names conform to the
1686 selected casing.
1687
1688 .. option:: PointerParameterPrefix
1689
1690 When defined, the check will ensure pointer parameter names will add the
1691 prefixed with the given value (regardless of casing).
1692
1693 .. option:: PointerParameterIgnoredRegexp
1694
1695 Identifier naming checks won't be enforced for pointer parameter names
1696 matching this regular expression.
1697
1698 .. option:: PointerParameterSuffix
1699
1700 When defined, the check will ensure pointer parameter names will add the
1701 suffix with the given value (regardless of casing).
1702
1703 .. option:: PointerParameterHungarianPrefix
1704
1705 When enabled, the check ensures that the declared identifier will
1706 have a Hungarian notation prefix based on the declared type.
1707
1708 For example using values of:
1709
1710 - PointerParameterCase of ``lower_case``
1711 - PointerParameterPrefix of ``pre_``
1712 - PointerParameterSuffix of ``_post``
1713 - PointerParameterHungarianPrefix of ``On``
1714
1715 Identifies and/or transforms pointer parameter names as follows:
1716
1717 Before:
1718
1719 .. code-block:: c++
1720
1721 void FUNCTION(int *PARAMETER);
1722
1723 After:
1724
1725 .. code-block:: c++
1726
1727 void FUNCTION(int *pre_parameter_post);
1728
1729 .. option:: PrivateMemberCase
1730
1731 When defined, the check will ensure private member names conform to the
1732 selected casing.
1733
1734 .. option:: PrivateMemberPrefix
1735
1736 When defined, the check will ensure private member names will add the
1737 prefixed with the given value (regardless of casing).
1738
1739 .. option:: PrivateMemberIgnoredRegexp
1740
1741 Identifier naming checks won't be enforced for private member names
1742 matching this regular expression.
1743
1744 .. option:: PrivateMemberSuffix
1745
1746 When defined, the check will ensure private member names will add the
1747 suffix with the given value (regardless of casing).
1748
1749 .. option:: PrivateMemberHungarianPrefix
1750
1751 When enabled, the check ensures that the declared identifier will
1752 have a Hungarian notation prefix based on the declared type.
1753
1754 For example using values of:
1755
1756 - PrivateMemberCase of ``lower_case``
1757 - PrivateMemberPrefix of ``pre_``
1758 - PrivateMemberSuffix of ``_post``
1759 - PrivateMemberHungarianPrefix of ``On``
1760
1761 Identifies and/or transforms private member names as follows:
1762
1763 Before:
1764
1765 .. code-block:: c++
1766
1767 class Foo {
1768 private:
1769 int Member_Variable;
1770 }
1771
1772 After:
1773
1774 .. code-block:: c++
1775
1776 class Foo {
1777 private:
1778 int pre_member_variable_post;
1779 }
1780
1781 .. option:: PrivateMethodCase
1782
1783 When defined, the check will ensure private method names conform to the
1784 selected casing.
1785
1786 .. option:: PrivateMethodPrefix
1787
1788 When defined, the check will ensure private method names will add the
1789 prefixed with the given value (regardless of casing).
1790
1791 .. option:: PrivateMethodIgnoredRegexp
1792
1793 Identifier naming checks won't be enforced for private method names
1794 matching this regular expression.
1795
1796 .. option:: PrivateMethodSuffix
1797
1798 When defined, the check will ensure private method names will add the
1799 suffix with the given value (regardless of casing).
1800
1801 For example using values of:
1802
1803 - PrivateMethodCase of ``lower_case``
1804 - PrivateMethodPrefix of ``pre_``
1805 - PrivateMethodSuffix of ``_post``
1806
1807 Identifies and/or transforms private method names as follows:
1808
1809 Before:
1810
1811 .. code-block:: c++
1812
1813 class Foo {
1814 private:
1815 int Member_Method();
1816 }
1817
1818 After:
1819
1820 .. code-block:: c++
1821
1822 class Foo {
1823 private:
1824 int pre_member_method_post();
1825 }
1826
1827 .. option:: ProtectedMemberCase
1828
1829 When defined, the check will ensure protected member names conform to the
1830 selected casing.
1831
1832 .. option:: ProtectedMemberPrefix
1833
1834 When defined, the check will ensure protected member names will add the
1835 prefixed with the given value (regardless of casing).
1836
1837 .. option:: ProtectedMemberIgnoredRegexp
1838
1839 Identifier naming checks won't be enforced for protected member names
1840 matching this regular expression.
1841
1842 .. option:: ProtectedMemberSuffix
1843
1844 When defined, the check will ensure protected member names will add the
1845 suffix with the given value (regardless of casing).
1846
1847 .. option:: ProtectedMemberHungarianPrefix
1848
1849 When enabled, the check ensures that the declared identifier will
1850 have a Hungarian notation prefix based on the declared type.
1851
1852 For example using values of:
1853
1854 - ProtectedMemberCase of ``lower_case``
1855 - ProtectedMemberPrefix of ``pre_``
1856 - ProtectedMemberSuffix of ``_post``
1857 - ProtectedMemberHungarianPrefix of ``On``
1858
1859 Identifies and/or transforms protected member names as follows:
1860
1861 Before:
1862
1863 .. code-block:: c++
1864
1865 class Foo {
1866 protected:
1867 int Member_Variable;
1868 }
1869
1870 After:
1871
1872 .. code-block:: c++
1873
1874 class Foo {
1875 protected:
1876 int pre_member_variable_post;
1877 }
1878
1879 .. option:: ProtectedMethodCase
1880
1881 When defined, the check will ensure protected method names conform to the
1882 selected casing.
1883
1884 .. option:: ProtectedMethodPrefix
1885
1886 When defined, the check will ensure protected method names will add the
1887 prefixed with the given value (regardless of casing).
1888
1889 .. option:: ProtectedMethodIgnoredRegexp
1890
1891 Identifier naming checks won't be enforced for protected method names
1892 matching this regular expression.
1893
1894 .. option:: ProtectedMethodSuffix
1895
1896 When defined, the check will ensure protected method names will add the
1897 suffix with the given value (regardless of casing).
1898
1899 For example using values of:
1900
1901 - ProtectedMethodCase of ``lower_case``
1902 - ProtectedMethodPrefix of ``pre_``
1903 - ProtectedMethodSuffix of ``_post``
1904
1905 Identifies and/or transforms protect method names as follows:
1906
1907 Before:
1908
1909 .. code-block:: c++
1910
1911 class Foo {
1912 protected:
1913 int Member_Method();
1914 }
1915
1916 After:
1917
1918 .. code-block:: c++
1919
1920 class Foo {
1921 protected:
1922 int pre_member_method_post();
1923 }
1924
1925 .. option:: PublicMemberCase
1926
1927 When defined, the check will ensure public member names conform to the
1928 selected casing.
1929
1930 .. option:: PublicMemberPrefix
1931
1932 When defined, the check will ensure public member names will add the
1933 prefixed with the given value (regardless of casing).
1934
1935 .. option:: PublicMemberIgnoredRegexp
1936
1937 Identifier naming checks won't be enforced for public member names
1938 matching this regular expression.
1939
1940 .. option:: PublicMemberSuffix
1941
1942 When defined, the check will ensure public member names will add the
1943 suffix with the given value (regardless of casing).
1944
1945 .. option:: PublicMemberHungarianPrefix
1946
1947 When enabled, the check ensures that the declared identifier will
1948 have a Hungarian notation prefix based on the declared type.
1949
1950 For example using values of:
1951
1952 - PublicMemberCase of ``lower_case``
1953 - PublicMemberPrefix of ``pre_``
1954 - PublicMemberSuffix of ``_post``
1955 - PublicMemberHungarianPrefix of ``On``
1956
1957 Identifies and/or transforms public member names as follows:
1958
1959 Before:
1960
1961 .. code-block:: c++
1962
1963 class Foo {
1964 public:
1965 int Member_Variable;
1966 }
1967
1968 After:
1969
1970 .. code-block:: c++
1971
1972 class Foo {
1973 public:
1974 int pre_member_variable_post;
1975 }
1976
1977 .. option:: PublicMethodCase
1978
1979 When defined, the check will ensure public method names conform to the
1980 selected casing.
1981
1982 .. option:: PublicMethodPrefix
1983
1984 When defined, the check will ensure public method names will add the
1985 prefixed with the given value (regardless of casing).
1986
1987 .. option:: PublicMethodIgnoredRegexp
1988
1989 Identifier naming checks won't be enforced for public method names
1990 matching this regular expression.
1991
1992 .. option:: PublicMethodSuffix
1993
1994 When defined, the check will ensure public method names will add the
1995 suffix with the given value (regardless of casing).
1996
1997 For example using values of:
1998
1999 - PublicMethodCase of ``lower_case``
2000 - PublicMethodPrefix of ``pre_``
2001 - PublicMethodSuffix of ``_post``
2002
2003 Identifies and/or transforms public method names as follows:
2004
2005 Before:
2006
2007 .. code-block:: c++
2008
2009 class Foo {
2010 public:
2011 int Member_Method();
2012 }
2013
2014 After:
2015
2016 .. code-block:: c++
2017
2018 class Foo {
2019 public:
2020 int pre_member_method_post();
2021 }
2022
2023 .. option:: ScopedEnumConstantCase
2024
2025 When defined, the check will ensure scoped enum constant names conform to
2026 the selected casing.
2027
2028 .. option:: ScopedEnumConstantPrefix
2029
2030 When defined, the check will ensure scoped enum constant names will add the
2031 prefixed with the given value (regardless of casing).
2032
2033 .. option:: ScopedEnumConstantIgnoredRegexp
2034
2035 Identifier naming checks won't be enforced for scoped enum constant names
2036 matching this regular expression.
2037
2038 .. option:: ScopedEnumConstantSuffix
2039
2040 When defined, the check will ensure scoped enum constant names will add the
2041 suffix with the given value (regardless of casing).
2042
2043 .. option:: ScopedEnumConstantHungarianPrefix
2044
2045 When enabled, the check ensures that the declared identifier will
2046 have a Hungarian notation prefix based on the declared type.
2047
2048 For example using values of:
2049
2050 - ScopedEnumConstantCase of ``lower_case``
2051 - ScopedEnumConstantPrefix of ``pre_``
2052 - ScopedEnumConstantSuffix of ``_post``
2053 - ScopedEnumConstantHungarianPrefix of ``On``
2054
2055 Identifies and/or transforms enumeration constant names as follows:
2056
2057 Before:
2058
2059 .. code-block:: c++
2060
2061 enum class FOO { One, Two, Three };
2062
2063 After:
2064
2065 .. code-block:: c++
2066
2067 enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };
2068
2069 .. option:: StaticConstantCase
2070
2071 When defined, the check will ensure static constant names conform to the
2072 selected casing.
2073
2074 .. option:: StaticConstantPrefix
2075
2076 When defined, the check will ensure static constant names will add the
2077 prefixed with the given value (regardless of casing).
2078
2079 .. option:: StaticConstantIgnoredRegexp
2080
2081 Identifier naming checks won't be enforced for static constant names
2082 matching this regular expression.
2083
2084 .. option:: StaticConstantSuffix
2085
2086 When defined, the check will ensure static constant names will add the
2087 suffix with the given value (regardless of casing).
2088
2089 .. option:: StaticConstantHungarianPrefix
2090
2091 When enabled, the check ensures that the declared identifier will
2092 have a Hungarian notation prefix based on the declared type.
2093
2094 For example using values of:
2095
2096 - StaticConstantCase of ``lower_case``
2097 - StaticConstantPrefix of ``pre_``
2098 - StaticConstantSuffix of ``_post``
2099 - StaticConstantHungarianPrefix of ``On``
2100
2101 Identifies and/or transforms static constant names as follows:
2102
2103 Before:
2104
2105 .. code-block:: c++
2106
2107 static unsigned const MyConstStatic_array[] = {1, 2, 3};
2108
2109 After:
2110
2111 .. code-block:: c++
2112
2113 static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};
2114
2115 .. option:: StaticVariableCase
2116
2117 When defined, the check will ensure static variable names conform to the
2118 selected casing.
2119
2120 .. option:: StaticVariablePrefix
2121
2122 When defined, the check will ensure static variable names will add the
2123 prefixed with the given value (regardless of casing).
2124
2125 .. option:: StaticVariableIgnoredRegexp
2126
2127 Identifier naming checks won't be enforced for static variable names
2128 matching this regular expression.
2129
2130 .. option:: StaticVariableSuffix
2131
2132 When defined, the check will ensure static variable names will add the
2133 suffix with the given value (regardless of casing).
2134
2135 .. option:: StaticVariableHungarianPrefix
2136
2137 When enabled, the check ensures that the declared identifier will
2138 have a Hungarian notation prefix based on the declared type.
2139
2140 For example using values of:
2141
2142 - StaticVariableCase of ``lower_case``
2143 - StaticVariablePrefix of ``pre_``
2144 - StaticVariableSuffix of ``_post``
2145 - StaticVariableHungarianPrefix of ``On``
2146
2147 Identifies and/or transforms static variable names as follows:
2148
2149 Before:
2150
2151 .. code-block:: c++
2152
2153 static unsigned MyStatic_array[] = {1, 2, 3};
2154
2155 After:
2156
2157 .. code-block:: c++
2158
2159 static unsigned pre_mystatic_array_post[] = {1, 2, 3};
2160
2161 .. option:: StructCase
2162
2163 When defined, the check will ensure struct names conform to the
2164 selected casing.
2165
2166 .. option:: StructPrefix
2167
2168 When defined, the check will ensure struct names will add the
2169 prefixed with the given value (regardless of casing).
2170
2171 .. option:: StructIgnoredRegexp
2172
2173 Identifier naming checks won't be enforced for struct names
2174 matching this regular expression.
2175
2176 .. option:: StructSuffix
2177
2178 When defined, the check will ensure struct names will add the
2179 suffix with the given value (regardless of casing).
2180
2181 For example using values of:
2182
2183 - StructCase of ``lower_case``
2184 - StructPrefix of ``pre_``
2185 - StructSuffix of ``_post``
2186
2187 Identifies and/or transforms struct names as follows:
2188
2189 Before:
2190
2191 .. code-block:: c++
2192
2193 struct FOO {
2194 FOO();
2195 ~FOO();
2196 };
2197
2198 After:
2199
2200 .. code-block:: c++
2201
2202 struct pre_foo_post {
2203 pre_foo_post();
2204 ~pre_foo_post();
2205 };
2206
2207 .. option:: TemplateParameterCase
2208
2209 When defined, the check will ensure template parameter names conform to the
2210 selected casing.
2211
2212 .. option:: TemplateParameterPrefix
2213
2214 When defined, the check will ensure template parameter names will add the
2215 prefixed with the given value (regardless of casing).
2216
2217 .. option:: TemplateParameterIgnoredRegexp
2218
2219 Identifier naming checks won't be enforced for template parameter names
2220 matching this regular expression.
2221
2222 .. option:: TemplateParameterSuffix
2223
2224 When defined, the check will ensure template parameter names will add the
2225 suffix with the given value (regardless of casing).
2226
2227 For example using values of:
2228
2229 - TemplateParameterCase of ``lower_case``
2230 - TemplateParameterPrefix of ``pre_``
2231 - TemplateParameterSuffix of ``_post``
2232
2233 Identifies and/or transforms template parameter names as follows:
2234
2235 Before:
2236
2237 .. code-block:: c++
2238
2239 template <typename T> class Foo {};
2240
2241 After:
2242
2243 .. code-block:: c++
2244
2245 template <typename pre_t_post> class Foo {};
2246
2247 .. option:: TemplateTemplateParameterCase
2248
2249 When defined, the check will ensure template template parameter names conform to the
2250 selected casing.
2251
2252 .. option:: TemplateTemplateParameterPrefix
2253
2254 When defined, the check will ensure template template parameter names will add the
2255 prefixed with the given value (regardless of casing).
2256
2257 .. option:: TemplateTemplateParameterIgnoredRegexp
2258
2259 Identifier naming checks won't be enforced for template template parameter
2260 names matching this regular expression.
2261
2262 .. option:: TemplateTemplateParameterSuffix
2263
2264 When defined, the check will ensure template template parameter names will add the
2265 suffix with the given value (regardless of casing).
2266
2267 For example using values of:
2268
2269 - TemplateTemplateParameterCase of ``lower_case``
2270 - TemplateTemplateParameterPrefix of ``pre_``
2271 - TemplateTemplateParameterSuffix of ``_post``
2272
2273 Identifies and/or transforms template template parameter names as follows:
2274
2275 Before:
2276
2277 .. code-block:: c++
2278
2279 template <template <typename> class TPL_parameter, int COUNT_params,
2280 typename... TYPE_parameters>
2281
2282 After:
2283
2284 .. code-block:: c++
2285
2286 template <template <typename> class pre_tpl_parameter_post, int COUNT_params,
2287 typename... TYPE_parameters>
2288
2289 .. option:: TypeAliasCase
2290
2291 When defined, the check will ensure type alias names conform to the
2292 selected casing.
2293
2294 .. option:: TypeAliasPrefix
2295
2296 When defined, the check will ensure type alias names will add the
2297 prefixed with the given value (regardless of casing).
2298
2299 .. option:: TypeAliasIgnoredRegexp
2300
2301 Identifier naming checks won't be enforced for type alias names
2302 matching this regular expression.
2303
2304 .. option:: TypeAliasSuffix
2305
2306 When defined, the check will ensure type alias names will add the
2307 suffix with the given value (regardless of casing).
2308
2309 For example using values of:
2310
2311 - TypeAliasCase of ``lower_case``
2312 - TypeAliasPrefix of ``pre_``
2313 - TypeAliasSuffix of ``_post``
2314
2315 Identifies and/or transforms type alias names as follows:
2316
2317 Before:
2318
2319 .. code-block:: c++
2320
2321 using MY_STRUCT_TYPE = my_structure;
2322
2323 After:
2324
2325 .. code-block:: c++
2326
2327 using pre_my_struct_type_post = my_structure;
2328
2329 .. option:: TypedefCase
2330
2331 When defined, the check will ensure typedef names conform to the
2332 selected casing.
2333
2334 .. option:: TypedefPrefix
2335
2336 When defined, the check will ensure typedef names will add the
2337 prefixed with the given value (regardless of casing).
2338
2339 .. option:: TypedefIgnoredRegexp
2340
2341 Identifier naming checks won't be enforced for typedef names
2342 matching this regular expression.
2343
2344 .. option:: TypedefSuffix
2345
2346 When defined, the check will ensure typedef names will add the
2347 suffix with the given value (regardless of casing).
2348
2349 For example using values of:
2350
2351 - TypedefCase of ``lower_case``
2352 - TypedefPrefix of ``pre_``
2353 - TypedefSuffix of ``_post``
2354
2355 Identifies and/or transforms typedef names as follows:
2356
2357 Before:
2358
2359 .. code-block:: c++
2360
2361 typedef int MYINT;
2362
2363 After:
2364
2365 .. code-block:: c++
2366
2367 typedef int pre_myint_post;
2368
2369 .. option:: TypeTemplateParameterCase
2370
2371 When defined, the check will ensure type template parameter names conform to the
2372 selected casing.
2373
2374 .. option:: TypeTemplateParameterPrefix
2375
2376 When defined, the check will ensure type template parameter names will add the
2377 prefixed with the given value (regardless of casing).
2378
2379 .. option:: TypeTemplateParameterIgnoredRegexp
2380
2381 Identifier naming checks won't be enforced for type template names
2382 matching this regular expression.
2383
2384 .. option:: TypeTemplateParameterSuffix
2385
2386 When defined, the check will ensure type template parameter names will add the
2387 suffix with the given value (regardless of casing).
2388
2389 For example using values of:
2390
2391 - TypeTemplateParameterCase of ``lower_case``
2392 - TypeTemplateParameterPrefix of ``pre_``
2393 - TypeTemplateParameterSuffix of ``_post``
2394
2395 Identifies and/or transforms type template parameter names as follows:
2396
2397 Before:
2398
2399 .. code-block:: c++
2400
2401 template <template <typename> class TPL_parameter, int COUNT_params,
2402 typename... TYPE_parameters>
2403
2404 After:
2405
2406 .. code-block:: c++
2407
2408 template <template <typename> class TPL_parameter, int COUNT_params,
2409 typename... pre_type_parameters_post>
2410
2411 .. option:: UnionCase
2412
2413 When defined, the check will ensure union names conform to the
2414 selected casing.
2415
2416 .. option:: UnionPrefix
2417
2418 When defined, the check will ensure union names will add the
2419 prefixed with the given value (regardless of casing).
2420
2421 .. option:: UnionIgnoredRegexp
2422
2423 Identifier naming checks won't be enforced for union names
2424 matching this regular expression.
2425
2426 .. option:: UnionSuffix
2427
2428 When defined, the check will ensure union names will add the
2429 suffix with the given value (regardless of casing).
2430
2431 For example using values of:
2432
2433 - UnionCase of ``lower_case``
2434 - UnionPrefix of ``pre_``
2435 - UnionSuffix of ``_post``
2436
2437 Identifies and/or transforms union names as follows:
2438
2439 Before:
2440
2441 .. code-block:: c++
2442
2443 union FOO {
2444 int a;
2445 char b;
2446 };
2447
2448 After:
2449
2450 .. code-block:: c++
2451
2452 union pre_foo_post {
2453 int a;
2454 char b;
2455 };
2456
2457 .. option:: ValueTemplateParameterCase
2458
2459 When defined, the check will ensure value template parameter names conform to the
2460 selected casing.
2461
2462 .. option:: ValueTemplateParameterPrefix
2463
2464 When defined, the check will ensure value template parameter names will add the
2465 prefixed with the given value (regardless of casing).
2466
2467 .. option:: ValueTemplateParameterIgnoredRegexp
2468
2469 Identifier naming checks won't be enforced for value template parameter
2470 names matching this regular expression.
2471
2472 .. option:: ValueTemplateParameterSuffix
2473
2474 When defined, the check will ensure value template parameter names will add the
2475 suffix with the given value (regardless of casing).
2476
2477 For example using values of:
2478
2479 - ValueTemplateParameterCase of ``lower_case``
2480 - ValueTemplateParameterPrefix of ``pre_``
2481 - ValueTemplateParameterSuffix of ``_post``
2482
2483 Identifies and/or transforms value template parameter names as follows:
2484
2485 Before:
2486
2487 .. code-block:: c++
2488
2489 template <template <typename> class TPL_parameter, int COUNT_params,
2490 typename... TYPE_parameters>
2491
2492 After:
2493
2494 .. code-block:: c++
2495
2496 template <template <typename> class TPL_parameter, int pre_count_params_post,
2497 typename... TYPE_parameters>
2498
2499 .. option:: VariableCase
2500
2501 When defined, the check will ensure variable names conform to the
2502 selected casing.
2503
2504 .. option:: VariablePrefix
2505
2506 When defined, the check will ensure variable names will add the
2507 prefixed with the given value (regardless of casing).
2508
2509 .. option:: VariableIgnoredRegexp
2510
2511 Identifier naming checks won't be enforced for variable names
2512 matching this regular expression.
2513
2514 .. option:: VariableSuffix
2515
2516 When defined, the check will ensure variable names will add the
2517 suffix with the given value (regardless of casing).
2518
2519 .. option:: VariableHungarianPrefix
2520
2521 When enabled, the check ensures that the declared identifier will
2522 have a Hungarian notation prefix based on the declared type.
2523
2524 For example using values of:
2525
2526 - VariableCase of ``lower_case``
2527 - VariablePrefix of ``pre_``
2528 - VariableSuffix of ``_post``
2529 - VariableHungarianPrefix of ``On``
2530
2531 Identifies and/or transforms variable names as follows:
2532
2533 Before:
2534
2535 .. code-block:: c++
2536
2537 unsigned MyVariable;
2538
2539 After:
2540
2541 .. code-block:: c++
2542
2543 unsigned pre_myvariable_post;
2544
2545 .. option:: VirtualMethodCase
2546
2547 When defined, the check will ensure virtual method names conform to the
2548 selected casing.
2549
2550 .. option:: VirtualMethodPrefix
2551
2552 When defined, the check will ensure virtual method names will add the
2553 prefixed with the given value (regardless of casing).
2554
2555 .. option:: VirtualMethodIgnoredRegexp
2556
2557 Identifier naming checks won't be enforced for virtual method names
2558 matching this regular expression.
2559
2560 .. option:: VirtualMethodSuffix
2561
2562 When defined, the check will ensure virtual method names will add the
2563 suffix with the given value (regardless of casing).
2564
2565 For example using values of:
2566
2567 - VirtualMethodCase of ``lower_case``
2568 - VirtualMethodPrefix of ``pre_``
2569 - VirtualMethodSuffix of ``_post``
2570
2571 Identifies and/or transforms virtual method names as follows:
2572
2573 Before:
2574
2575 .. code-block:: c++
2576
2577 class Foo {
2578 public:
2579 virtual int MemberFunction();
2580 }
2581
2582 After:
2583
2584 .. code-block:: c++
2585
2586 class Foo {
2587 public:
2588 virtual int pre_member_function_post();
2589 }
2590
2591
2592 The default mapping table of Hungarian Notation
2593 -----------------------------------------------
2594
2595 In Hungarian notation, a variable name starts with a group of lower-case
2596 letters which are mnemonics for the type or purpose of that variable, followed
2597 by whatever name the programmer has chosen; this last part is sometimes
2598 distinguished as the given name. The first character of the given name can be
2599 capitalized to separate it from the type indicators (see also CamelCase).
2600 Otherwise the case of this character denotes scope.
2601
2602 The following table is the default mapping table of Hungarian Notation which
2603 maps Decl to its prefix string. You can also have your own style in config file.
2604
2605 ================= ============== ====================== ============== ============== ==============
2606 Primitive Type Microsoft Type
2607 ----------------- -------------- ---------------------- -------------- -------------- --------------
2608 Type Prefix Type Prefix Type Prefix
2609 ================= ============== ====================== ============== ============== ==============
2610 int8_t i8 signed int si BOOL b
2611 int16_t i16 signed short ss BOOLEAN b
2612 int32_t i32 signed short int ssi BYTE by
2613 int64_t i64 signed long long int slli CHAR c
2614 uint8_t u8 signed long long sll UCHAR uc
2615 uint16_t u16 signed long int sli SHORT s
2616 uint32_t u32 signed long sl USHORT us
2617 uint64_t u64 signed s WORD w
2618 char8_t c8 unsigned long long int ulli DWORD dw
2619 char16_t c16 unsigned long long ull DWORD32 dw32
2620 char32_t c32 unsigned long int uli DWORD64 dw64
2621 float f unsigned long ul LONG l
2622 double d unsigned short int usi ULONG ul
2623 char c unsigned short us ULONG32 ul32
2624 bool b unsigned int ui ULONG64 ul64
2625 _Bool b unsigned char uc ULONGLONG ull
2626 int i unsigned u HANDLE h
2627 size_t n long long int lli INT i
2628 short s long double ld INT8 i8
2629 signed i long long ll INT16 i16
2630 unsigned u long int li INT32 i32
2631 long l long l INT64 i64
2632 long long ll ptrdiff_t p UINT ui
2633 unsigned long ul void *none* UINT8 u8
2634 long double ld UINT16 u16
2635 ptrdiff_t p UINT32 u32
2636 wchar_t wc UINT64 u64
2637 short int si PVOID p
2638 short s
2639 ================= ============== ====================== ============== ============== ==============
2640
2641 **There are more trivial options for Hungarian Notation:**
2642
2643 **HungarianNotation.General.***
2644 Options are not belonging to any specific Decl.
2645
2646 **HungarianNotation.CString.***
2647 Options for NULL-terminated string.
2648
2649 **HungarianNotation.DerivedType.***
2650 Options for derived types.
2651
2652 **HungarianNotation.PrimitiveType.***
2653 Options for primitive types.
2654
2655 **HungarianNotation.UserDefinedType.***
2656 Options for user-defined types.
2657
2658
2659 Options for Hungarian Notation
2660 ------------------------------
2661
2662 - :option:`HungarianNotation.General.TreatStructAsClass`
2663
2664 - :option:`HungarianNotation.DerivedType.Array`
2665 - :option:`HungarianNotation.DerivedType.Pointer`
2666 - :option:`HungarianNotation.DerivedType.FunctionPointer`
2667
2668 - :option:`HungarianNotation.CString.CharPointer`
2669 - :option:`HungarianNotation.CString.CharArray`
2670 - :option:`HungarianNotation.CString.WideCharPointer`
2671 - :option:`HungarianNotation.CString.WideCharArray`
2672
2673 - :option:`HungarianNotation.PrimitiveType.*`
2674 - :option:`HungarianNotation.UserDefinedType.*`
2675
2676 .. option:: HungarianNotation.General.TreatStructAsClass
2677
2678 When defined, the check will treat naming of struct as a class.
2679 The default value is `false`.
2680
2681 .. option:: HungarianNotation.DerivedType.Array
2682
2683 When defined, the check will ensure variable name will add the prefix with
2684 the given string. The default prefix is `a`.
2685
2686 .. option:: HungarianNotation.DerivedType.Pointer
2687
2688 When defined, the check will ensure variable name will add the prefix with
2689 the given string. The default prefix is `p`.
2690
2691 .. option:: HungarianNotation.DerivedType.FunctionPointer
2692
2693 When defined, the check will ensure variable name will add the prefix with
2694 the given string. The default prefix is `fn`.
2695
2696
2697 Before:
2698
2699 .. code-block:: c++
2700
2701 // Array
2702 int DataArray[2] = {0};
2703
2704 // Pointer
2705 void *DataBuffer = NULL;
2706
2707 // FunctionPointer
2708 typedef void (*FUNC_PTR)();
2709 FUNC_PTR FuncPtr = NULL;
2710
2711 After:
2712
2713 .. code-block:: c++
2714
2715 // Array
2716 int aDataArray[2] = {0};
2717
2718 // Pointer
2719 void *pDataBuffer = NULL;
2720
2721 // FunctionPointer
2722 typedef void (*FUNC_PTR)();
2723 FUNC_PTR fnFuncPtr = NULL;
2724
2725
2726 .. option:: HungarianNotation.CString.CharPointer
2727
2728 When defined, the check will ensure variable name will add the prefix with
2729 the given string. The default prefix is `sz`.
2730
2731 .. option:: HungarianNotation.CString.CharArray
2732
2733 When defined, the check will ensure variable name will add the prefix with
2734 the given string. The default prefix is `sz`.
2735
2736 .. option:: HungarianNotation.CString.WideCharPointer
2737
2738 When defined, the check will ensure variable name will add the prefix with
2739 the given string. The default prefix is `wsz`.
2740
2741 .. option:: HungarianNotation.CString.WideCharArray
2742
2743 When defined, the check will ensure variable name will add the prefix with
2744 the given string. The default prefix is `wsz`.
2745
2746
2747 Before:
2748
2749 .. code-block:: c++
2750
2751 // CharPointer
2752 const char *NamePtr = "Name";
2753
2754 // CharArray
2755 const char NameArray[] = "Name";
2756
2757 // WideCharPointer
2758 const wchar_t *WideNamePtr = L"Name";
2759
2760 // WideCharArray
2761 const wchar_t WideNameArray[] = L"Name";
2762
2763 After:
2764
2765 .. code-block:: c++
2766
2767 // CharPointer
2768 const char *szNamePtr = "Name";
2769
2770 // CharArray
2771 const char szNameArray[] = "Name";
2772
2773 // WideCharPointer
2774 const wchar_t *wszWideNamePtr = L"Name";
2775
2776 // WideCharArray
2777 const wchar_t wszWideNameArray[] = L"Name";
2778
2779
2780 .. option:: HungarianNotation.PrimitiveType.*
2781
2782 When defined, the check will ensure variable name of involved primitive
2783 types will add the prefix with the given string. The default prefixes are
2784 defined in the default mapping table.
2785
2786 .. option:: HungarianNotation.UserDefinedType.*
2787
2788 When defined, the check will ensure variable name of involved primitive
2789 types will add the prefix with the given string. The default prefixes are
2790 defined in the default mapping table.
2791
2792
2793 Before:
2794
2795 .. code-block:: c++
2796
2797 int8_t ValueI8 = 0;
2798 int16_t ValueI16 = 0;
2799 int32_t ValueI32 = 0;
2800 int64_t ValueI64 = 0;
2801 uint8_t ValueU8 = 0;
2802 uint16_t ValueU16 = 0;
2803 uint32_t ValueU32 = 0;
2804 uint64_t ValueU64 = 0;
2805 float ValueFloat = 0.0;
2806 double ValueDouble = 0.0;
2807 ULONG ValueUlong = 0;
2808 DWORD ValueDword = 0;
2809
2810 After:
2811
2812 .. code-block:: c++
2813
2814 int8_t i8ValueI8 = 0;
2815 int16_t i16ValueI16 = 0;
2816 int32_t i32ValueI32 = 0;
2817 int64_t i64ValueI64 = 0;
2818 uint8_t u8ValueU8 = 0;
2819 uint16_t u16ValueU16 = 0;
2820 uint32_t u32ValueU32 = 0;
2821 uint64_t u64ValueU64 = 0;
2822 float fValueFloat = 0.0;
2823 double dValueDouble = 0.0;
2824 ULONG ulValueUlong = 0;
2825 DWORD dwValueDword = 0;