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

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