brintos / llvm-project-archived public Read only

1.. title:: clang-tidy - readability-identifier-naming2 3readability-identifier-naming4=============================5 6Checks for identifiers naming style mismatch.7 8This check will try to enforce coding guidelines on the identifiers naming. It9supports one of the following casing types and tries to convert from one to10another if a mismatch is detected11 12Casing 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 23It also supports a fixed prefix and suffix that will be prepended or appended24to the identifiers, regardless of the casing.25 26Many configuration options are available, in order to be able to create27different rules for different kinds of identifiers. In general, the rules are28falling back to a more generic rule if the specific case is not configured.29 30The naming of virtual methods is reported where they occur in the base class,31but not where they are overridden, as it can't be fixed locally there.32This also applies for pseudo-override patterns like CRTP.33 34``Leading_upper_snake_case`` is a naming convention where the first word is35capitalized followed by lower case word(s) separated by underscore(s) '_'.36Examples include: `Cap_snake_case`, `Cobra_case`, `Foo_bar_baz`,37and `Master_copy_8gb`.38 39Hungarian notation can be customized using different *HungarianPrefix*40settings. The options and their corresponding values are:41 42 - ``Off`` - the default setting43 - ``On`` - example: ``int iVariable``44 - ``LowerCase`` - example: ``int i_Variable``45 - ``CamelCase`` - example: ``int IVariable``46 47Options summary48---------------49 50The available options are summarized below:51 52**General options**53 54 - :option:`AggressiveDependentMemberLookup`55 - :option:`CheckAnonFieldInParent`56 - :option:`GetConfigPerFile`57 - :option:`IgnoreMainLikeFunctions`58 59**Specific options**60 61 - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`,62   :option:`AbstractClassSuffix`, :option:`AbstractClassIgnoredRegexp`,63   :option:`AbstractClassHungarianPrefix`64 - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix`,65   :option:`ClassIgnoredRegexp`, :option:`ClassHungarianPrefix`66 - :option:`ClassConstexprCase`, :option:`ClassConstexprPrefix`,67   :option:`ClassConstexprSuffix`, :option:`ClassConstexprIgnoredRegexp`,68   :option:`ClassConstexprHungarianPrefix`69 - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`,70   :option:`ClassConstantSuffix`, :option:`ClassConstantIgnoredRegexp`,71   :option:`ClassConstantHungarianPrefix`72 - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`,73   :option:`ClassMemberSuffix`, :option:`ClassMemberIgnoredRegexp`,74   :option:`ClassMemberHungarianPrefix`75 - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`,76   :option:`ClassMethodSuffix`, :option:`ClassMethodIgnoredRegexp`77 - :option:`ConceptCase`, :option:`ConceptPrefix`, :option:`ConceptSuffix`,78   :option:`ConceptIgnoredRegexp`79 - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix`,80   :option:`ConstantIgnoredRegexp`, :option:`ConstantHungarianPrefix`81 - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`,82   :option:`ConstantMemberSuffix`, :option:`ConstantMemberIgnoredRegexp`,83   :option:`ConstantMemberHungarianPrefix`84 - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`,85   :option:`ConstantParameterSuffix`, :option:`ConstantParameterIgnoredRegexp`,86   :option:`ConstantParameterHungarianPrefix`87 - :option:`ConstantPointerParameterCase`,88   :option:`ConstantPointerParameterPrefix`,89   :option:`ConstantPointerParameterSuffix`,90   :option:`ConstantPointerParameterIgnoredRegexp`,91   :option:`ConstantPointerParameterHungarianPrefix`92 - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`,93   :option:`ConstexprFunctionSuffix`, :option:`ConstexprFunctionIgnoredRegexp`94 - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`,95   :option:`ConstexprMethodSuffix`, :option:`ConstexprMethodIgnoredRegexp`96 - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`,97   :option:`ConstexprVariableSuffix`, :option:`ConstexprVariableIgnoredRegexp`,98   :option:`ConstexprVariableHungarianPrefix`99 - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix`,100   :option:`EnumIgnoredRegexp`101 - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`,102   :option:`EnumConstantSuffix`, :option:`EnumConstantIgnoredRegexp`,103   :option:`EnumConstantHungarianPrefix`104 - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix`,105   :option:`FunctionIgnoredRegexp`106 - :option:`GlobalConstexprVariableCase`,107   :option:`GlobalConstexprVariablePrefix`,108   :option:`GlobalConstexprVariableSuffix`,109   :option:`GlobalConstexprVariableIgnoredRegexp`,110   :option:`GlobalConstexprVariableHungarianPrefix`111 - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`,112   :option:`GlobalConstantSuffix`, :option:`GlobalConstantIgnoredRegexp`,113   :option:`GlobalConstantHungarianPrefix`114 - :option:`GlobalConstantPointerCase`,115   :option:`GlobalConstantPointerPrefix`,116   :option:`GlobalConstantPointerSuffix`,117   :option:`GlobalConstantPointerIgnoredRegexp`,118   :option:`GlobalConstantPointerHungarianPrefix`119 - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`,120   :option:`GlobalFunctionSuffix`, :option:`GlobalFunctionIgnoredRegexp`121 - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`,122   :option:`GlobalPointerSuffix`, :option:`GlobalPointerIgnoredRegexp`,123   :option:`GlobalPointerHungarianPrefix`124 - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`,125   :option:`GlobalVariableSuffix`, :option:`GlobalVariableIgnoredRegexp`,126   :option:`GlobalVariableHungarianPrefix`127 - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`,128   :option:`InlineNamespaceSuffix`, :option:`InlineNamespaceIgnoredRegexp`129 - :option:`LocalConstexprVariableCase`,130   :option:`LocalConstexprVariablePrefix`,131   :option:`LocalConstexprVariableSuffix`,132   :option:`LocalConstexprVariableIgnoredRegexp`,133   :option:`LocalConstexprVariableHungarianPrefix`134 - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`,135   :option:`LocalConstantSuffix`, :option:`LocalConstantIgnoredRegexp`,136   :option:`LocalConstantHungarianPrefix`137 - :option:`LocalConstantPointerCase`,138   :option:`LocalConstantPointerPrefix`,139   :option:`LocalConstantPointerSuffix`,140   :option:`LocalConstantPointerIgnoredRegexp`,141   :option:`LocalConstantPointerHungarianPrefix`142 - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`,143   :option:`LocalPointerSuffix`, :option:`LocalPointerIgnoredRegexp`,144   :option:`LocalPointerHungarianPrefix`145 - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`,146   :option:`LocalVariableSuffix`, :option:`LocalVariableIgnoredRegexp`,147   :option:`LocalVariableHungarianPrefix`148 - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`,149   :option:`MacroDefinitionSuffix`, :option:`MacroDefinitionIgnoredRegexp`150 - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix`,151   :option:`MemberIgnoredRegexp`, :option:`MemberHungarianPrefix`152 - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix`,153   :option:`MethodIgnoredRegexp`154 - :option:`NamespaceCase`, :option:`NamespacePrefix`,155   :option:`NamespaceSuffix`, :option:`NamespaceIgnoredRegexp`156 - :option:`ParameterCase`, :option:`ParameterPrefix`,157   :option:`ParameterSuffix`, :option:`ParameterIgnoredRegexp`,158   :option:`ParameterHungarianPrefix`159 - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`,160   :option:`ParameterPackSuffix`, :option:`ParameterPackIgnoredRegexp`161 - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`,162   :option:`PointerParameterSuffix`, :option:`PointerParameterIgnoredRegexp`,163   :option:`PointerParameterHungarianPrefix`164 - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`,165   :option:`PrivateMemberSuffix`, :option:`PrivateMemberIgnoredRegexp`,166   :option:`PrivateMemberHungarianPrefix`167 - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`,168   :option:`PrivateMethodSuffix`, :option:`PrivateMethodIgnoredRegexp`169 - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`,170   :option:`ProtectedMemberSuffix`, :option:`ProtectedMemberIgnoredRegexp`,171   :option:`ProtectedMemberHungarianPrefix`172 - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`,173   :option:`ProtectedMethodSuffix`, :option:`ProtectedMethodIgnoredRegexp`174 - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`,175   :option:`PublicMemberSuffix`, :option:`PublicMemberIgnoredRegexp`,176   :option:`PublicMemberHungarianPrefix`177 - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`,178   :option:`PublicMethodSuffix`, :option:`PublicMethodIgnoredRegexp`179 - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`,180   :option:`ScopedEnumConstantSuffix`,181   :option:`ScopedEnumConstantIgnoredRegexp`182 - :option:`StaticConstexprVariableCase`,183   :option:`StaticConstexprVariablePrefix`,184   :option:`StaticConstexprVariableSuffix`,185   :option:`StaticConstexprVariableIgnoredRegexp`,186   :option:`StaticConstexprVariableHungarianPrefix`187 - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`,188   :option:`StaticConstantSuffix`, :option:`StaticConstantIgnoredRegexp`,189   :option:`StaticConstantHungarianPrefix`190 - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`,191   :option:`StaticVariableSuffix`, :option:`StaticVariableIgnoredRegexp`,192   :option:`StaticVariableHungarianPrefix`193 - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix`,194   :option:`StructIgnoredRegexp`195 - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`,196   :option:`TemplateParameterSuffix`, :option:`TemplateParameterIgnoredRegexp`197 - :option:`TemplateTemplateParameterCase`,198   :option:`TemplateTemplateParameterPrefix`,199   :option:`TemplateTemplateParameterSuffix`,200   :option:`TemplateTemplateParameterIgnoredRegexp`201 - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`,202   :option:`TypeAliasSuffix`, :option:`TypeAliasIgnoredRegexp`203 - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix`,204   :option:`TypedefIgnoredRegexp`205 - :option:`TypeTemplateParameterCase`,206   :option:`TypeTemplateParameterPrefix`,207   :option:`TypeTemplateParameterSuffix`,208   :option:`TypeTemplateParameterIgnoredRegexp`209 - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix`,210   :option:`UnionIgnoredRegexp`211 - :option:`ValueTemplateParameterCase`,212   :option:`ValueTemplateParameterPrefix`,213   :option:`ValueTemplateParameterSuffix`,214   :option:`ValueTemplateParameterIgnoredRegexp`215 - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix`,216   :option:`VariableIgnoredRegexp`, :option:`VariableHungarianPrefix`217 - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`,218   :option:`VirtualMethodSuffix`, :option:`VirtualMethodIgnoredRegexp`219 220 221Options description222-------------------223 224A detailed description of each option is presented below:225 226.. option:: AbstractClassCase227 228    When defined, the check will ensure abstract class names conform to the229    selected casing.230 231.. option:: AbstractClassPrefix232 233    When defined, the check will ensure abstract class names will add the234    prefixed with the given value (regardless of casing).235 236.. option:: AbstractClassIgnoredRegexp237 238    Identifier naming checks won't be enforced for abstract class names239    matching this regular expression.240 241.. option:: AbstractClassSuffix242 243    When defined, the check will ensure abstract class names will add the244    suffix with the given value (regardless of casing).245 246.. option:: AbstractClassHungarianPrefix247 248    When enabled, the check ensures that the declared identifier will249    have a Hungarian notation prefix based on the declared type.250 251For example using values of:252 253   - AbstractClassCase of ``lower_case``254   - AbstractClassPrefix of ``pre_``255   - AbstractClassSuffix of ``_post``256   - AbstractClassHungarianPrefix of ``On``257 258 259Identifies and/or transforms abstract class names as follows:260 261Before:262 263.. code-block:: c++264 265    class ABSTRACT_CLASS {266    public:267      ABSTRACT_CLASS();268    };269 270After:271 272.. code-block:: c++273 274    class pre_abstract_class_post {275    public:276      pre_abstract_class_post();277    };278 279.. option:: AggressiveDependentMemberLookup280 281    When set to `true` the check will look in dependent base classes for dependent282    member references that need changing. This can lead to errors with template283    specializations so the default value is `false`.284 285For example using values of:286 287   - ClassMemberCase of ``lower_case``288 289Before:290 291.. code-block:: c++292 293    template <typename T>294    struct Base {295      T BadNamedMember;296    };297 298    template <typename T>299    struct Derived : Base<T> {300      void reset() {301        this->BadNamedMember = 0;302      }303    };304 305After if AggressiveDependentMemberLookup is `false`:306 307.. code-block:: c++308 309    template <typename T>310    struct Base {311      T bad_named_member;312    };313 314    template <typename T>315    struct Derived : Base<T> {316      void reset() {317        this->BadNamedMember = 0;318      }319    };320 321After if AggressiveDependentMemberLookup is `true`:322 323.. code-block:: c++324 325    template <typename T>326    struct Base {327      T bad_named_member;328    };329 330    template <typename T>331    struct Derived : Base<T> {332      void reset() {333        this->bad_named_member = 0;334      }335    };336 337.. option:: CheckAnonFieldInParent338 339    When set to `true`, fields in anonymous records (i.e. anonymous340    unions and structs) will be treated as names in the enclosing scope341    rather than public members of the anonymous record for the purpose342    of name checking.343 344For example:345 346.. code-block:: c++347 348    class Foo {349    private:350      union {351        int iv_;352        float fv_;353      };354    };355 356If :option:`CheckAnonFieldInParent` is `false`, you may get warnings357that ``iv_`` and ``fv_`` are not coherent to public member names, because358``iv_`` and ``fv_`` are public members of the anonymous union. When359:option:`CheckAnonFieldInParent` is `true`, ``iv_`` and ``fv_`` will be360treated as private data members of ``Foo`` for the purpose of name checking361and thus no warnings will be emitted.362 363.. option:: ClassCase364 365    When defined, the check will ensure class names conform to the366    selected casing.367 368.. option:: ClassPrefix369 370    When defined, the check will ensure class names will add the371    prefixed with the given value (regardless of casing).372 373.. option:: ClassIgnoredRegexp374 375    Identifier naming checks won't be enforced for class names matching376    this regular expression.377 378.. option:: ClassSuffix379 380    When defined, the check will ensure class names will add the381    suffix with the given value (regardless of casing).382 383.. option:: ClassHungarianPrefix384 385    When enabled, the check ensures that the declared identifier will386    have a Hungarian notation prefix based on the declared type.387 388For example using values of:389 390   - ClassCase of ``lower_case``391   - ClassPrefix of ``pre_``392   - ClassSuffix of ``_post``393   - ClassHungarianPrefix of ``On``394 395Identifies and/or transforms class names as follows:396 397Before:398 399.. code-block:: c++400 401    class FOO {402    public:403      FOO();404      ~FOO();405    };406 407After:408 409.. code-block:: c++410 411    class pre_foo_post {412    public:413      pre_foo_post();414      ~pre_foo_post();415    };416 417.. option:: ClassConstexprCase418 419    When defined, the check will ensure class ``constexpr`` names conform to420    the selected casing.421 422.. option:: ClassConstexprPrefix423 424    When defined, the check will ensure class ``constexpr`` names will add the425    prefixed with the given value (regardless of casing).426 427.. option:: ClassConstexprIgnoredRegexp428 429    Identifier naming checks won't be enforced for class ``constexpr`` names430    matching this regular expression.431 432.. option:: ClassConstexprSuffix433 434    When defined, the check will ensure class ``constexpr`` names will add the435    suffix with the given value (regardless of casing).436 437.. option:: ClassConstexprHungarianPrefix438 439    When enabled, the check ensures that the declared identifier will have a440    Hungarian notation prefix based on the declared type.441 442For example using values of:443 444   - ClassConstexprCase of ``lower_case``445   - ClassConstexprPrefix of ``pre_``446   - ClassConstexprSuffix of ``_post``447   - ClassConstexprHungarianPrefix of ``On``448 449Identifies and/or transforms class ``constexpr`` variable names as follows:450 451Before:452 453.. code-block:: c++454 455    class FOO {456    public:457      static constexpr int CLASS_CONSTEXPR;458    };459 460After:461 462.. code-block:: c++463 464    class FOO {465    public:466      static const int pre_class_constexpr_post;467    };468 469.. option:: ClassConstantCase470 471    When defined, the check will ensure class constant names conform to the472    selected casing.473 474.. option:: ClassConstantPrefix475 476    When defined, the check will ensure class constant names will add the477    prefixed with the given value (regardless of casing).478 479.. option:: ClassConstantIgnoredRegexp480 481    Identifier naming checks won't be enforced for class constant names482    matching this regular expression.483 484.. option:: ClassConstantSuffix485 486    When defined, the check will ensure class constant names will add the487    suffix with the given value (regardless of casing).488 489.. option:: ClassConstantHungarianPrefix490 491    When enabled, the check ensures that the declared identifier will492    have a Hungarian notation prefix based on the declared type.493 494For example using values of:495 496   - ClassConstantCase of ``lower_case``497   - ClassConstantPrefix of ``pre_``498   - ClassConstantSuffix of ``_post``499   - ClassConstantHungarianPrefix of ``On``500 501Identifies and/or transforms class constant names as follows:502 503Before:504 505.. code-block:: c++506 507    class FOO {508    public:509      static const int CLASS_CONSTANT;510    };511 512After:513 514.. code-block:: c++515 516    class FOO {517    public:518      static const int pre_class_constant_post;519    };520 521.. option:: ClassMemberCase522 523    When defined, the check will ensure class member names conform to the524    selected casing.525 526.. option:: ClassMemberPrefix527 528    When defined, the check will ensure class member names will add the529    prefixed with the given value (regardless of casing).530 531.. option:: ClassMemberIgnoredRegexp532 533    Identifier naming checks won't be enforced for class member names534    matching this regular expression.535 536.. option:: ClassMemberSuffix537 538    When defined, the check will ensure class member names will add the539    suffix with the given value (regardless of casing).540 541.. option:: ClassMemberHungarianPrefix542 543    When enabled, the check ensures that the declared identifier will544    have a Hungarian notation prefix based on the declared type.545 546For example using values of:547 548   - ClassMemberCase of ``lower_case``549   - ClassMemberPrefix of ``pre_``550   - ClassMemberSuffix of ``_post``551   - ClassMemberHungarianPrefix of ``On``552 553Identifies and/or transforms class member names as follows:554 555Before:556 557.. code-block:: c++558 559    class FOO {560    public:561      static int CLASS_CONSTANT;562    };563 564After:565 566.. code-block:: c++567 568    class FOO {569    public:570      static int pre_class_constant_post;571    };572 573.. option:: ClassMethodCase574 575    When defined, the check will ensure class method names conform to the576    selected casing.577 578.. option:: ClassMethodPrefix579 580    When defined, the check will ensure class method names will add the581    prefixed with the given value (regardless of casing).582 583.. option:: ClassMethodIgnoredRegexp584 585    Identifier naming checks won't be enforced for class method names586    matching this regular expression.587 588.. option:: ClassMethodSuffix589 590    When defined, the check will ensure class method names will add the591    suffix with the given value (regardless of casing).592 593For example using values of:594 595   - ClassMethodCase of ``lower_case``596   - ClassMethodPrefix of ``pre_``597   - ClassMethodSuffix of ``_post``598 599Identifies and/or transforms class method names as follows:600 601Before:602 603.. code-block:: c++604 605    class FOO {606    public:607      int CLASS_MEMBER();608    };609 610After:611 612.. code-block:: c++613 614    class FOO {615    public:616      int pre_class_member_post();617    };618 619.. option:: ConceptCase620 621    When defined, the check will ensure concept names conform to the622    selected casing.623 624.. option:: ConceptPrefix625 626    When defined, the check will ensure concept names will add the627    prefixed with the given value (regardless of casing).628 629.. option:: ConceptIgnoredRegexp630 631    Identifier naming checks won't be enforced for concept names632    matching this regular expression.633 634.. option:: ConceptSuffix635 636    When defined, the check will ensure concept names will add the637    suffix with the given value (regardless of casing).638 639For example using values of:640 641   - ConceptCase of ``CamelCase``642   - ConceptPrefix of ``Pre``643   - ConceptSuffix of ``Post``644 645Identifies and/or transforms concept names as follows:646 647Before:648 649.. code-block:: c++650 651    template<typename T> concept my_concept = requires (T t) { {t++}; };652 653After:654 655.. code-block:: c++656 657    template<typename T> concept PreMyConceptPost = requires (T t) { {t++}; };658 659.. option:: ConstantCase660 661    When defined, the check will ensure constant names conform to the662    selected casing.663 664.. option:: ConstantPrefix665 666    When defined, the check will ensure constant names will add the667    prefixed with the given value (regardless of casing).668 669.. option:: ConstantIgnoredRegexp670 671    Identifier naming checks won't be enforced for constant names672    matching this regular expression.673 674.. option:: ConstantSuffix675 676    When defined, the check will ensure constant names will add the677    suffix with the given value (regardless of casing).678 679.. option:: ConstantHungarianPrefix680 681    When enabled, the check ensures that the declared identifier will682    have a Hungarian notation prefix based on the declared type.683 684For example using values of:685 686   - ConstantCase of ``lower_case``687   - ConstantPrefix of ``pre_``688   - ConstantSuffix of ``_post``689   - ConstantHungarianPrefix of ``On``690 691Identifies and/or transforms constant names as follows:692 693Before:694 695.. code-block:: c++696 697    void function() { unsigned const MyConst_array[] = {1, 2, 3}; }698 699After:700 701.. code-block:: c++702 703    void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }704 705.. option:: ConstantMemberCase706 707    When defined, the check will ensure constant member names conform to the708    selected casing.709 710.. option:: ConstantMemberPrefix711 712    When defined, the check will ensure constant member names will add the713    prefixed with the given value (regardless of casing).714 715.. option:: ConstantMemberIgnoredRegexp716 717    Identifier naming checks won't be enforced for constant member names718    matching this regular expression.719 720.. option:: ConstantMemberSuffix721 722    When defined, the check will ensure constant member names will add the723    suffix with the given value (regardless of casing).724 725.. option:: ConstantMemberHungarianPrefix726 727    When enabled, the check ensures that the declared identifier will728    have a Hungarian notation prefix based on the declared type.729 730For example using values of:731 732   - ConstantMemberCase of ``lower_case``733   - ConstantMemberPrefix of ``pre_``734   - ConstantMemberSuffix of ``_post``735   - ConstantMemberHungarianPrefix of ``On``736 737Identifies and/or transforms constant member names as follows:738 739Before:740 741.. code-block:: c++742 743    class Foo {744      char const MY_ConstMember_string[4] = "123";745    }746 747After:748 749.. code-block:: c++750 751    class Foo {752      char const pre_my_constmember_string_post[4] = "123";753    }754 755.. option:: ConstantParameterCase756 757    When defined, the check will ensure constant parameter names conform to the758    selected casing.759 760.. option:: ConstantParameterPrefix761 762    When defined, the check will ensure constant parameter names will add the763    prefixed with the given value (regardless of casing).764 765.. option:: ConstantParameterIgnoredRegexp766 767    Identifier naming checks won't be enforced for constant parameter names768    matching this regular expression.769 770.. option:: ConstantParameterSuffix771 772    When defined, the check will ensure constant parameter names will add the773    suffix with the given value (regardless of casing).774 775.. option:: ConstantParameterHungarianPrefix776 777    When enabled, the check ensures that the declared identifier will778    have a Hungarian notation prefix based on the declared type.779 780For example using values of:781 782   - ConstantParameterCase of ``lower_case``783   - ConstantParameterPrefix of ``pre_``784   - ConstantParameterSuffix of ``_post``785   - ConstantParameterHungarianPrefix of ``On``786 787Identifies and/or transforms constant parameter names as follows:788 789Before:790 791.. code-block:: c++792 793    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);794 795After:796 797.. code-block:: c++798 799    void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);800 801.. option:: ConstantPointerParameterCase802 803    When defined, the check will ensure constant pointer parameter names conform to the804    selected casing.805 806.. option:: ConstantPointerParameterPrefix807 808    When defined, the check will ensure constant pointer parameter names will add the809    prefixed with the given value (regardless of casing).810 811.. option:: ConstantPointerParameterIgnoredRegexp812 813    Identifier naming checks won't be enforced for constant pointer parameter814    names matching this regular expression.815 816.. option:: ConstantPointerParameterSuffix817 818    When defined, the check will ensure constant pointer parameter names will add the819    suffix with the given value (regardless of casing).820 821.. option:: ConstantPointerParameterHungarianPrefix822 823    When enabled, the check ensures that the declared identifier will824    have a Hungarian notation prefix based on the declared type.825 826For example using values of:827 828   - ConstantPointerParameterCase of ``lower_case``829   - ConstantPointerParameterPrefix of ``pre_``830   - ConstantPointerParameterSuffix of ``_post``831   - ConstantPointerParameterHungarianPrefix of ``On``832 833Identifies and/or transforms constant pointer parameter names as follows:834 835Before:836 837.. code-block:: c++838 839    void GLOBAL_FUNCTION(int const *CONST_parameter);840 841After:842 843.. code-block:: c++844 845    void GLOBAL_FUNCTION(int const *pre_const_parameter_post);846 847.. option:: ConstexprFunctionCase848 849    When defined, the check will ensure constexpr function names conform to the850    selected casing.851 852.. option:: ConstexprFunctionPrefix853 854    When defined, the check will ensure constexpr function names will add the855    prefixed with the given value (regardless of casing).856 857.. option:: ConstexprFunctionIgnoredRegexp858 859    Identifier naming checks won't be enforced for constexpr function names860    matching this regular expression.861 862.. option:: ConstexprFunctionSuffix863 864    When defined, the check will ensure constexpr function names will add the865    suffix with the given value (regardless of casing).866 867For example using values of:868 869   - ConstexprFunctionCase of ``lower_case``870   - ConstexprFunctionPrefix of ``pre_``871   - ConstexprFunctionSuffix of ``_post``872 873Identifies and/or transforms constexpr function names as follows:874 875Before:876 877.. code-block:: c++878 879    constexpr int CE_function() { return 3; }880 881After:882 883.. code-block:: c++884 885    constexpr int pre_ce_function_post() { return 3; }886 887.. option:: ConstexprMethodCase888 889    When defined, the check will ensure constexpr method names conform to the890    selected casing.891 892.. option:: ConstexprMethodPrefix893 894    When defined, the check will ensure constexpr method names will add the895    prefixed with the given value (regardless of casing).896 897.. option:: ConstexprMethodIgnoredRegexp898 899    Identifier naming checks won't be enforced for constexpr method names900    matching this regular expression.901 902.. option:: ConstexprMethodSuffix903 904    When defined, the check will ensure constexpr method names will add the905    suffix with the given value (regardless of casing).906 907For example using values of:908 909   - ConstexprMethodCase of ``lower_case``910   - ConstexprMethodPrefix of ``pre_``911   - ConstexprMethodSuffix of ``_post``912 913Identifies and/or transforms constexpr method names as follows:914 915Before:916 917.. code-block:: c++918 919    class Foo {920    public:921      constexpr int CST_expr_Method() { return 2; }922    }923 924After:925 926.. code-block:: c++927 928    class Foo {929    public:930      constexpr int pre_cst_expr_method_post() { return 2; }931    }932 933.. option:: ConstexprVariableCase934 935    When defined, the check will ensure constexpr variable names conform to the936    selected casing.937 938.. option:: ConstexprVariablePrefix939 940    When defined, the check will ensure constexpr variable names will add the941    prefixed with the given value (regardless of casing).942 943.. option:: ConstexprVariableIgnoredRegexp944 945    Identifier naming checks won't be enforced for constexpr variable names946    matching this regular expression.947 948.. option:: ConstexprVariableSuffix949 950    When defined, the check will ensure constexpr variable names will add the951    suffix with the given value (regardless of casing).952 953.. option:: ConstexprVariableHungarianPrefix954 955    When enabled, the check ensures that the declared identifier will956    have a Hungarian notation prefix based on the declared type.957 958For example using values of:959 960   - ConstexprVariableCase of ``lower_case``961   - ConstexprVariablePrefix of ``pre_``962   - ConstexprVariableSuffix of ``_post``963   - ConstexprVariableHungarianPrefix of ``On``964 965Identifies and/or transforms constexpr variable names as follows:966 967Before:968 969.. code-block:: c++970 971    constexpr int ConstExpr_variable = MyConstant;972 973After:974 975.. code-block:: c++976 977    constexpr int pre_constexpr_variable_post = MyConstant;978 979.. option:: EnumCase980 981    When defined, the check will ensure enumeration names conform to the982    selected casing.983 984.. option:: EnumPrefix985 986    When defined, the check will ensure enumeration names will add the987    prefixed with the given value (regardless of casing).988 989.. option:: EnumIgnoredRegexp990 991    Identifier naming checks won't be enforced for enumeration names992    matching this regular expression.993 994.. option:: EnumSuffix995 996    When defined, the check will ensure enumeration names will add the997    suffix with the given value (regardless of casing).998 999For example using values of:1000 1001   - EnumCase of ``lower_case``1002   - EnumPrefix of ``pre_``1003   - EnumSuffix of ``_post``1004 1005Identifies and/or transforms enumeration names as follows:1006 1007Before:1008 1009.. code-block:: c++1010 1011    enum FOO { One, Two, Three };1012 1013After:1014 1015.. code-block:: c++1016 1017    enum pre_foo_post { One, Two, Three };1018 1019.. option:: EnumConstantCase1020 1021    When defined, the check will ensure enumeration constant names conform to the1022    selected casing.1023 1024.. option:: EnumConstantPrefix1025 1026    When defined, the check will ensure enumeration constant names will add the1027    prefixed with the given value (regardless of casing).1028 1029.. option:: EnumConstantIgnoredRegexp1030 1031    Identifier naming checks won't be enforced for enumeration constant names1032    matching this regular expression.1033 1034.. option:: EnumConstantSuffix1035 1036    When defined, the check will ensure enumeration constant names will add the1037    suffix with the given value (regardless of casing).1038 1039.. option:: EnumConstantHungarianPrefix1040 1041    When enabled, the check ensures that the declared identifier will1042    have a Hungarian notation prefix based on the declared type.1043 1044For example using values of:1045 1046   - EnumConstantCase of ``lower_case``1047   - EnumConstantPrefix of ``pre_``1048   - EnumConstantSuffix of ``_post``1049   - EnumConstantHungarianPrefix of ``On``1050 1051Identifies and/or transforms enumeration constant names as follows:1052 1053Before:1054 1055.. code-block:: c++1056 1057    enum FOO { One, Two, Three };1058 1059After:1060 1061.. code-block:: c++1062 1063    enum FOO { pre_One_post, pre_Two_post, pre_Three_post };1064 1065.. option:: FunctionCase1066 1067    When defined, the check will ensure function names conform to the1068    selected casing.1069 1070.. option:: FunctionPrefix1071 1072    When defined, the check will ensure function names will add the1073    prefixed with the given value (regardless of casing).1074 1075.. option:: FunctionIgnoredRegexp1076 1077    Identifier naming checks won't be enforced for function names1078    matching this regular expression.1079 1080.. option:: FunctionSuffix1081 1082    When defined, the check will ensure function names will add the1083    suffix with the given value (regardless of casing).1084 1085For example using values of:1086 1087   - FunctionCase of ``lower_case``1088   - FunctionPrefix of ``pre_``1089   - FunctionSuffix of ``_post``1090 1091Identifies and/or transforms function names as follows:1092 1093Before:1094 1095.. code-block:: c++1096 1097    char MY_Function_string();1098 1099After:1100 1101.. code-block:: c++1102 1103    char pre_my_function_string_post();1104 1105.. option:: GetConfigPerFile1106 1107    When `true` the check will look for the configuration for where an1108    identifier is declared. Useful for when included header files use a1109    different style.1110    Default value is `true`.1111 1112.. option:: GlobalConstexprVariableCase1113 1114    When defined, the check will ensure global ``constexpr`` variable names1115    conform to the selected casing.1116 1117.. option:: GlobalConstexprVariablePrefix1118 1119    When defined, the check will ensure global ``constexpr`` variable names1120    will add the prefixed with the given value (regardless of casing).1121 1122.. option:: GlobalConstexprVariableIgnoredRegexp1123 1124    Identifier naming checks won't be enforced for global ``constexpr``1125    variable names matching this regular expression.1126 1127.. option:: GlobalConstexprVariableSuffix1128 1129    When defined, the check will ensure global ``constexpr`` variable names1130    will add the suffix with the given value (regardless of casing).1131 1132.. option:: GlobalConstexprVariableHungarianPrefix1133 1134    When enabled, the check ensures that the declared identifier will have a1135    Hungarian notation prefix based on the declared type.1136 1137For example using values of:1138 1139   - GlobalConstexprVariableCase of ``lower_case``1140   - GlobalConstexprVariablePrefix of ``pre_``1141   - GlobalConstexprVariableSuffix of ``_post``1142   - GlobalConstexprVariableHungarianPrefix of ``On``1143 1144Identifies and/or transforms global ``constexpr`` variable names as follows:1145 1146Before:1147 1148.. code-block:: c++1149 1150    constexpr unsigned ImportantValue = 69;1151 1152After:1153 1154.. code-block:: c++1155 1156    constexpr unsigned pre_important_value_post = 69;1157 1158.. option:: GlobalConstantCase1159 1160    When defined, the check will ensure global constant names conform to the1161    selected casing.1162 1163.. option:: GlobalConstantPrefix1164 1165    When defined, the check will ensure global constant names will add the1166    prefixed with the given value (regardless of casing).1167 1168.. option:: GlobalConstantIgnoredRegexp1169 1170    Identifier naming checks won't be enforced for global constant names1171    matching this regular expression.1172 1173.. option:: GlobalConstantSuffix1174 1175    When defined, the check will ensure global constant names will add the1176    suffix with the given value (regardless of casing).1177 1178.. option:: GlobalConstantHungarianPrefix1179 1180    When enabled, the check ensures that the declared identifier will1181    have a Hungarian notation prefix based on the declared type.1182 1183For example using values of:1184 1185   - GlobalConstantCase of ``lower_case``1186   - GlobalConstantPrefix of ``pre_``1187   - GlobalConstantSuffix of ``_post``1188   - GlobalConstantHungarianPrefix of ``On``1189 1190Identifies and/or transforms global constant names as follows:1191 1192Before:1193 1194.. code-block:: c++1195 1196    unsigned const MyConstGlobal_array[] = {1, 2, 3};1197 1198After:1199 1200.. code-block:: c++1201 1202    unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};1203 1204.. option:: GlobalConstantPointerCase1205 1206    When defined, the check will ensure global constant pointer names conform to the1207    selected casing.1208 1209.. option:: GlobalConstantPointerPrefix1210 1211    When defined, the check will ensure global constant pointer names will add the1212    prefixed with the given value (regardless of casing).1213 1214.. option:: GlobalConstantPointerIgnoredRegexp1215 1216    Identifier naming checks won't be enforced for global constant pointer1217    names matching this regular expression.1218 1219.. option:: GlobalConstantPointerSuffix1220 1221    When defined, the check will ensure global constant pointer names will add the1222    suffix with the given value (regardless of casing).1223 1224.. option:: GlobalConstantPointerHungarianPrefix1225 1226    When enabled, the check ensures that the declared identifier will1227    have a Hungarian notation prefix based on the declared type.1228 1229For example using values of:1230 1231   - GlobalConstantPointerCase of ``lower_case``1232   - GlobalConstantPointerPrefix of ``pre_``1233   - GlobalConstantPointerSuffix of ``_post``1234   - GlobalConstantPointerHungarianPrefix of ``On``1235 1236Identifies and/or transforms global constant pointer names as follows:1237 1238Before:1239 1240.. code-block:: c++1241 1242    int *const MyConstantGlobalPointer = nullptr;1243 1244After:1245 1246.. code-block:: c++1247 1248    int *const pre_myconstantglobalpointer_post = nullptr;1249 1250.. option:: GlobalFunctionCase1251 1252    When defined, the check will ensure global function names conform to the1253    selected casing.1254 1255.. option:: GlobalFunctionPrefix1256 1257    When defined, the check will ensure global function names will add the1258    prefixed with the given value (regardless of casing).1259 1260.. option:: GlobalFunctionIgnoredRegexp1261 1262    Identifier naming checks won't be enforced for global function names1263    matching this regular expression.1264 1265.. option:: GlobalFunctionSuffix1266 1267    When defined, the check will ensure global function names will add the1268    suffix with the given value (regardless of casing).1269 1270For example using values of:1271 1272   - GlobalFunctionCase of ``lower_case``1273   - GlobalFunctionPrefix of ``pre_``1274   - GlobalFunctionSuffix of ``_post``1275 1276Identifies and/or transforms global function names as follows:1277 1278Before:1279 1280.. code-block:: c++1281 1282    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);1283 1284After:1285 1286.. code-block:: c++1287 1288    void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);1289 1290.. option:: GlobalPointerCase1291 1292    When defined, the check will ensure global pointer names conform to the1293    selected casing.1294 1295.. option:: GlobalPointerPrefix1296 1297    When defined, the check will ensure global pointer names will add the1298    prefixed with the given value (regardless of casing).1299 1300.. option:: GlobalPointerIgnoredRegexp1301 1302    Identifier naming checks won't be enforced for global pointer names1303    matching this regular expression.1304 1305.. option:: GlobalPointerSuffix1306 1307    When defined, the check will ensure global pointer names will add the1308    suffix with the given value (regardless of casing).1309 1310.. option:: GlobalPointerHungarianPrefix1311 1312    When enabled, the check ensures that the declared identifier will1313    have a Hungarian notation prefix based on the declared type.1314 1315For example using values of:1316 1317   - GlobalPointerCase of ``lower_case``1318   - GlobalPointerPrefix of ``pre_``1319   - GlobalPointerSuffix of ``_post``1320   - GlobalPointerHungarianPrefix of ``On``1321 1322Identifies and/or transforms global pointer names as follows:1323 1324Before:1325 1326.. code-block:: c++1327 1328    int *GLOBAL3;1329 1330After:1331 1332.. code-block:: c++1333 1334    int *pre_global3_post;1335 1336.. option:: GlobalVariableCase1337 1338    When defined, the check will ensure global variable names conform to the1339    selected casing.1340 1341.. option:: GlobalVariablePrefix1342 1343    When defined, the check will ensure global variable names will add the1344    prefixed with the given value (regardless of casing).1345 1346.. option:: GlobalVariableIgnoredRegexp1347 1348    Identifier naming checks won't be enforced for global variable names1349    matching this regular expression.1350 1351.. option:: GlobalVariableSuffix1352 1353    When defined, the check will ensure global variable names will add the1354    suffix with the given value (regardless of casing).1355 1356.. option:: GlobalVariableHungarianPrefix1357 1358    When enabled, the check ensures that the declared identifier will1359    have a Hungarian notation prefix based on the declared type.1360 1361For example using values of:1362 1363   - GlobalVariableCase of ``lower_case``1364   - GlobalVariablePrefix of ``pre_``1365   - GlobalVariableSuffix of ``_post``1366   - GlobalVariableHungarianPrefix of ``On``1367 1368Identifies and/or transforms global variable names as follows:1369 1370Before:1371 1372.. code-block:: c++1373 1374    int GLOBAL3;1375 1376After:1377 1378.. code-block:: c++1379 1380    int pre_global3_post;1381 1382.. option:: IgnoreMainLikeFunctions1383 1384    When set to `true` functions that have a similar signature to ``main`` or1385    ``wmain`` won't enforce checks on the names of their parameters.1386    Default value is `false`.1387 1388.. option:: InlineNamespaceCase1389 1390    When defined, the check will ensure inline namespaces names conform to the1391    selected casing.1392 1393.. option:: InlineNamespacePrefix1394 1395    When defined, the check will ensure inline namespaces names will add the1396    prefixed with the given value (regardless of casing).1397 1398.. option:: InlineNamespaceIgnoredRegexp1399 1400    Identifier naming checks won't be enforced for inline namespaces names1401    matching this regular expression.1402 1403.. option:: InlineNamespaceSuffix1404 1405    When defined, the check will ensure inline namespaces names will add the1406    suffix with the given value (regardless of casing).1407 1408For example using values of:1409 1410   - InlineNamespaceCase of ``lower_case``1411   - InlineNamespacePrefix of ``pre_``1412   - InlineNamespaceSuffix of ``_post``1413 1414Identifies and/or transforms inline namespaces names as follows:1415 1416Before:1417 1418.. code-block:: c++1419 1420    namespace FOO_NS {1421    inline namespace InlineNamespace {1422    ...1423    }1424    } // namespace FOO_NS1425 1426After:1427 1428.. code-block:: c++1429 1430    namespace FOO_NS {1431    inline namespace pre_inlinenamespace_post {1432    ...1433    }1434    } // namespace FOO_NS1435 1436.. option:: LocalConstexprVariableCase1437 1438    When defined, the check will ensure local ``constexpr`` variable names1439    conform to the selected casing.1440 1441.. option:: LocalConstexprVariablePrefix1442 1443    When defined, the check will ensure local ``constexpr`` variable names will1444    add the prefixed with the given value (regardless of casing).1445 1446.. option:: LocalConstexprVariableIgnoredRegexp1447 1448    Identifier naming checks won't be enforced for local ``constexpr`` variable1449    names matching this regular expression.1450 1451.. option:: LocalConstexprVariableSuffix1452 1453    When defined, the check will ensure local ``constexpr`` variable names will1454    add the suffix with the given value (regardless of casing).1455 1456.. option:: LocalConstexprVariableHungarianPrefix1457 1458    When enabled, the check ensures that the declared identifier will have a1459    Hungarian notation prefix based on the declared type.1460 1461For example using values of:1462 1463   - LocalConstexprVariableCase of ``lower_case``1464   - LocalConstexprVariablePrefix of ``pre_``1465   - LocalConstexprVariableSuffix of ``_post``1466   - LocalConstexprVariableHungarianPrefix of ``On``1467 1468Identifies and/or transforms local ``constexpr`` variable names as follows:1469 1470Before:1471 1472.. code-block:: c++1473 1474    void foo() { int const local_Constexpr = 420; }1475 1476After:1477 1478.. code-block:: c++1479 1480    void foo() { int const pre_local_constexpr_post = 420; }1481 1482.. option:: LocalConstantCase1483 1484    When defined, the check will ensure local constant names conform to the1485    selected casing.1486 1487.. option:: LocalConstantPrefix1488 1489    When defined, the check will ensure local constant names will add the1490    prefixed with the given value (regardless of casing).1491 1492.. option:: LocalConstantIgnoredRegexp1493 1494    Identifier naming checks won't be enforced for local constant names1495    matching this regular expression.1496 1497.. option:: LocalConstantSuffix1498 1499    When defined, the check will ensure local constant names will add the1500    suffix with the given value (regardless of casing).1501 1502.. option:: LocalConstantHungarianPrefix1503 1504    When enabled, the check ensures that the declared identifier will1505    have a Hungarian notation prefix based on the declared type.1506 1507For example using values of:1508 1509   - LocalConstantCase of ``lower_case``1510   - LocalConstantPrefix of ``pre_``1511   - LocalConstantSuffix of ``_post``1512   - LocalConstantHungarianPrefix of ``On``1513 1514Identifies and/or transforms local constant names as follows:1515 1516Before:1517 1518.. code-block:: c++1519 1520    void foo() { int const local_Constant = 3; }1521 1522After:1523 1524.. code-block:: c++1525 1526    void foo() { int const pre_local_constant_post = 3; }1527 1528.. option:: LocalConstantPointerCase1529 1530    When defined, the check will ensure local constant pointer names conform to the1531    selected casing.1532 1533.. option:: LocalConstantPointerPrefix1534 1535    When defined, the check will ensure local constant pointer names will add the1536    prefixed with the given value (regardless of casing).1537 1538.. option:: LocalConstantPointerIgnoredRegexp1539 1540    Identifier naming checks won't be enforced for local constant pointer names1541    matching this regular expression.1542 1543.. option:: LocalConstantPointerSuffix1544 1545    When defined, the check will ensure local constant pointer names will add the1546    suffix with the given value (regardless of casing).1547 1548.. option:: LocalConstantPointerHungarianPrefix1549 1550    When enabled, the check ensures that the declared identifier will1551    have a Hungarian notation prefix based on the declared type.1552 1553For example using values of:1554 1555   - LocalConstantPointerCase of ``lower_case``1556   - LocalConstantPointerPrefix of ``pre_``1557   - LocalConstantPointerSuffix of ``_post``1558   - LocalConstantPointerHungarianPrefix of ``On``1559 1560Identifies and/or transforms local constant pointer names as follows:1561 1562Before:1563 1564.. code-block:: c++1565 1566    void foo() { int const *local_Constant = 3; }1567 1568After:1569 1570.. code-block:: c++1571 1572    void foo() { int const *pre_local_constant_post = 3; }1573 1574.. option:: LocalPointerCase1575 1576    When defined, the check will ensure local pointer names conform to the1577    selected casing.1578 1579.. option:: LocalPointerPrefix1580 1581    When defined, the check will ensure local pointer names will add the1582    prefixed with the given value (regardless of casing).1583 1584.. option:: LocalPointerIgnoredRegexp1585 1586    Identifier naming checks won't be enforced for local pointer names1587    matching this regular expression.1588 1589.. option:: LocalPointerSuffix1590 1591    When defined, the check will ensure local pointer names will add the1592    suffix with the given value (regardless of casing).1593 1594.. option:: LocalPointerHungarianPrefix1595 1596    When enabled, the check ensures that the declared identifier will1597    have a Hungarian notation prefix based on the declared type.1598 1599For example using values of:1600 1601   - LocalPointerCase of ``lower_case``1602   - LocalPointerPrefix of ``pre_``1603   - LocalPointerSuffix of ``_post``1604   - LocalPointerHungarianPrefix of ``On``1605 1606Identifies and/or transforms local pointer names as follows:1607 1608Before:1609 1610.. code-block:: c++1611 1612    void foo() { int *local_Constant; }1613 1614After:1615 1616.. code-block:: c++1617 1618    void foo() { int *pre_local_constant_post; }1619 1620.. option:: LocalVariableCase1621 1622    When defined, the check will ensure local variable names conform to the1623    selected casing.1624 1625.. option:: LocalVariablePrefix1626 1627    When defined, the check will ensure local variable names will add the1628    prefixed with the given value (regardless of casing).1629 1630.. option:: LocalVariableIgnoredRegexp1631 1632    Identifier naming checks won't be enforced for local variable names1633    matching this regular expression.1634 1635For example using values of:1636 1637   - LocalVariableCase of ``CamelCase``1638   - LocalVariableIgnoredRegexp of ``\w{1,2}``1639 1640Will exclude variables with a length less than or equal to 2 from the1641camel case check applied to other variables.1642 1643.. option:: LocalVariableSuffix1644 1645    When defined, the check will ensure local variable names will add the1646    suffix with the given value (regardless of casing).1647 1648.. option:: LocalVariableHungarianPrefix1649 1650    When enabled, the check ensures that the declared identifier will1651    have a Hungarian notation prefix based on the declared type.1652 1653For example using values of:1654 1655   - LocalVariableCase of ``lower_case``1656   - LocalVariablePrefix of ``pre_``1657   - LocalVariableSuffix of ``_post``1658   - LocalVariableHungarianPrefix of ``On``1659 1660Identifies and/or transforms local variable names as follows:1661 1662Before:1663 1664.. code-block:: c++1665 1666    void foo() { int local_Constant; }1667 1668After:1669 1670.. code-block:: c++1671 1672    void foo() { int pre_local_constant_post; }1673 1674.. option:: MacroDefinitionCase1675 1676    When defined, the check will ensure macro definitions conform to the1677    selected casing.1678 1679.. option:: MacroDefinitionPrefix1680 1681    When defined, the check will ensure macro definitions will add the1682    prefixed with the given value (regardless of casing).1683 1684.. option:: MacroDefinitionIgnoredRegexp1685 1686    Identifier naming checks won't be enforced for macro definitions1687    matching this regular expression.1688 1689.. option:: MacroDefinitionSuffix1690 1691    When defined, the check will ensure macro definitions will add the1692    suffix with the given value (regardless of casing).1693 1694For example using values of:1695 1696   - MacroDefinitionCase of ``lower_case``1697   - MacroDefinitionPrefix of ``pre_``1698   - MacroDefinitionSuffix of ``_post``1699 1700Identifies and/or transforms macro definitions as follows:1701 1702Before:1703 1704.. code-block:: c1705 1706    #define MY_MacroDefinition1707 1708After:1709 1710.. code-block:: c1711 1712    #define pre_my_macro_definition_post1713 1714Note: This will not warn on builtin macros or macros defined on the1715command line using the ``-D`` flag.1716 1717.. option:: MemberCase1718 1719    When defined, the check will ensure member names conform to the1720    selected casing.1721 1722.. option:: MemberPrefix1723 1724    When defined, the check will ensure member names will add the1725    prefixed with the given value (regardless of casing).1726 1727.. option:: MemberIgnoredRegexp1728 1729    Identifier naming checks won't be enforced for member names1730    matching this regular expression.1731 1732.. option:: MemberSuffix1733 1734    When defined, the check will ensure member names will add the1735    suffix with the given value (regardless of casing).1736 1737.. option:: MemberHungarianPrefix1738 1739    When enabled, the check ensures that the declared identifier will1740    have a Hungarian notation prefix based on the declared type.1741 1742For example using values of:1743 1744   - MemberCase of ``lower_case``1745   - MemberPrefix of ``pre_``1746   - MemberSuffix of ``_post``1747   - MemberHungarianPrefix of ``On``1748 1749Identifies and/or transforms member names as follows:1750 1751Before:1752 1753.. code-block:: c++1754 1755    class Foo {1756      char MY_ConstMember_string[4];1757    }1758 1759After:1760 1761.. code-block:: c++1762 1763    class Foo {1764      char pre_my_constmember_string_post[4];1765    }1766 1767.. option:: MethodCase1768 1769    When defined, the check will ensure method names conform to the1770    selected casing.1771 1772.. option:: MethodPrefix1773 1774    When defined, the check will ensure method names will add the1775    prefixed with the given value (regardless of casing).1776 1777.. option:: MethodIgnoredRegexp1778 1779    Identifier naming checks won't be enforced for method names1780    matching this regular expression.1781 1782.. option:: MethodSuffix1783 1784    When defined, the check will ensure method names will add the1785    suffix with the given value (regardless of casing).1786 1787For example using values of:1788 1789   - MethodCase of ``lower_case``1790   - MethodPrefix of ``pre_``1791   - MethodSuffix of ``_post``1792 1793Identifies and/or transforms method names as follows:1794 1795Before:1796 1797.. code-block:: c++1798 1799    class Foo {1800      char MY_Method_string();1801    }1802 1803After:1804 1805.. code-block:: c++1806 1807    class Foo {1808      char pre_my_method_string_post();1809    }1810 1811.. option:: NamespaceCase1812 1813    When defined, the check will ensure namespace names conform to the1814    selected casing.1815 1816.. option:: NamespacePrefix1817 1818    When defined, the check will ensure namespace names will add the1819    prefixed with the given value (regardless of casing).1820 1821.. option:: NamespaceIgnoredRegexp1822 1823    Identifier naming checks won't be enforced for namespace names1824    matching this regular expression.1825 1826.. option:: NamespaceSuffix1827 1828    When defined, the check will ensure namespace names will add the1829    suffix with the given value (regardless of casing).1830 1831For example using values of:1832 1833   - NamespaceCase of ``lower_case``1834   - NamespacePrefix of ``pre_``1835   - NamespaceSuffix of ``_post``1836 1837Identifies and/or transforms namespace names as follows:1838 1839Before:1840 1841.. code-block:: c++1842 1843    namespace FOO_NS {1844    ...1845    }1846 1847After:1848 1849.. code-block:: c++1850 1851    namespace pre_foo_ns_post {1852    ...1853    }1854 1855.. option:: ParameterCase1856 1857    When defined, the check will ensure parameter names conform to the1858    selected casing.1859 1860.. option:: ParameterPrefix1861 1862    When defined, the check will ensure parameter names will add the1863    prefixed with the given value (regardless of casing).1864 1865.. option:: ParameterIgnoredRegexp1866 1867    Identifier naming checks won't be enforced for parameter names1868    matching this regular expression.1869 1870.. option:: ParameterSuffix1871 1872    When defined, the check will ensure parameter names will add the1873    suffix with the given value (regardless of casing).1874 1875.. option:: ParameterHungarianPrefix1876 1877    When enabled, the check ensures that the declared identifier will1878    have a Hungarian notation prefix based on the declared type.1879 1880For example using values of:1881 1882   - ParameterCase of ``lower_case``1883   - ParameterPrefix of ``pre_``1884   - ParameterSuffix of ``_post``1885   - ParameterHungarianPrefix of ``On``1886 1887Identifies and/or transforms parameter names as follows:1888 1889Before:1890 1891.. code-block:: c++1892 1893    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);1894 1895After:1896 1897.. code-block:: c++1898 1899    void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);1900 1901.. option:: ParameterPackCase1902 1903    When defined, the check will ensure parameter pack names conform to the1904    selected casing.1905 1906.. option:: ParameterPackPrefix1907 1908    When defined, the check will ensure parameter pack names will add the1909    prefixed with the given value (regardless of casing).1910 1911.. option:: ParameterPackIgnoredRegexp1912 1913    Identifier naming checks won't be enforced for parameter pack names1914    matching this regular expression.1915 1916.. option:: ParameterPackSuffix1917 1918    When defined, the check will ensure parameter pack names will add the1919    suffix with the given value (regardless of casing).1920 1921For example using values of:1922 1923   - ParameterPackCase of ``lower_case``1924   - ParameterPackPrefix of ``pre_``1925   - ParameterPackSuffix of ``_post``1926 1927Identifies and/or transforms parameter pack names as follows:1928 1929Before:1930 1931.. code-block:: c++1932 1933    template <typename... TYPE_parameters> {1934      void FUNCTION(int... TYPE_parameters);1935    }1936 1937After:1938 1939.. code-block:: c++1940 1941    template <typename... TYPE_parameters> {1942      void FUNCTION(int... pre_type_parameters_post);1943    }1944 1945.. option:: PointerParameterCase1946 1947    When defined, the check will ensure pointer parameter names conform to the1948    selected casing.1949 1950.. option:: PointerParameterPrefix1951 1952    When defined, the check will ensure pointer parameter names will add the1953    prefixed with the given value (regardless of casing).1954 1955.. option:: PointerParameterIgnoredRegexp1956 1957    Identifier naming checks won't be enforced for pointer parameter names1958    matching this regular expression.1959 1960.. option:: PointerParameterSuffix1961 1962    When defined, the check will ensure pointer parameter names will add the1963    suffix with the given value (regardless of casing).1964 1965.. option:: PointerParameterHungarianPrefix1966 1967    When enabled, the check ensures that the declared identifier will1968    have a Hungarian notation prefix based on the declared type.1969 1970For example using values of:1971 1972   - PointerParameterCase of ``lower_case``1973   - PointerParameterPrefix of ``pre_``1974   - PointerParameterSuffix of ``_post``1975   - PointerParameterHungarianPrefix of ``On``1976 1977Identifies and/or transforms pointer parameter names as follows:1978 1979Before:1980 1981.. code-block:: c++1982 1983    void FUNCTION(int *PARAMETER);1984 1985After:1986 1987.. code-block:: c++1988 1989    void FUNCTION(int *pre_parameter_post);1990 1991.. option:: PrivateMemberCase1992 1993    When defined, the check will ensure private member names conform to the1994    selected casing.1995 1996.. option:: PrivateMemberPrefix1997 1998    When defined, the check will ensure private member names will add the1999    prefixed with the given value (regardless of casing).2000 2001.. option:: PrivateMemberIgnoredRegexp2002 2003    Identifier naming checks won't be enforced for private member names2004    matching this regular expression.2005 2006.. option:: PrivateMemberSuffix2007 2008    When defined, the check will ensure private member names will add the2009    suffix with the given value (regardless of casing).2010 2011.. option:: PrivateMemberHungarianPrefix2012 2013    When enabled, the check ensures that the declared identifier will2014    have a Hungarian notation prefix based on the declared type.2015 2016For example using values of:2017 2018   - PrivateMemberCase of ``lower_case``2019   - PrivateMemberPrefix of ``pre_``2020   - PrivateMemberSuffix of ``_post``2021   - PrivateMemberHungarianPrefix of ``On``2022 2023Identifies and/or transforms private member names as follows:2024 2025Before:2026 2027.. code-block:: c++2028 2029    class Foo {2030    private:2031      int Member_Variable;2032    }2033 2034After:2035 2036.. code-block:: c++2037 2038    class Foo {2039    private:2040      int pre_member_variable_post;2041    }2042 2043.. option:: PrivateMethodCase2044 2045    When defined, the check will ensure private method names conform to the2046    selected casing.2047 2048.. option:: PrivateMethodPrefix2049 2050    When defined, the check will ensure private method names will add the2051    prefixed with the given value (regardless of casing).2052 2053.. option:: PrivateMethodIgnoredRegexp2054 2055    Identifier naming checks won't be enforced for private method names2056    matching this regular expression.2057 2058.. option:: PrivateMethodSuffix2059 2060    When defined, the check will ensure private method names will add the2061    suffix with the given value (regardless of casing).2062 2063For example using values of:2064 2065   - PrivateMethodCase of ``lower_case``2066   - PrivateMethodPrefix of ``pre_``2067   - PrivateMethodSuffix of ``_post``2068 2069Identifies and/or transforms private method names as follows:2070 2071Before:2072 2073.. code-block:: c++2074 2075    class Foo {2076    private:2077      int Member_Method();2078    }2079 2080After:2081 2082.. code-block:: c++2083 2084    class Foo {2085    private:2086      int pre_member_method_post();2087    }2088 2089.. option:: ProtectedMemberCase2090 2091    When defined, the check will ensure protected member names conform to the2092    selected casing.2093 2094.. option:: ProtectedMemberPrefix2095 2096    When defined, the check will ensure protected member names will add the2097    prefixed with the given value (regardless of casing).2098 2099.. option:: ProtectedMemberIgnoredRegexp2100 2101    Identifier naming checks won't be enforced for protected member names2102    matching this regular expression.2103 2104.. option:: ProtectedMemberSuffix2105 2106    When defined, the check will ensure protected member names will add the2107    suffix with the given value (regardless of casing).2108 2109.. option:: ProtectedMemberHungarianPrefix2110 2111    When enabled, the check ensures that the declared identifier will2112    have a Hungarian notation prefix based on the declared type.2113 2114For example using values of:2115 2116   - ProtectedMemberCase of ``lower_case``2117   - ProtectedMemberPrefix of ``pre_``2118   - ProtectedMemberSuffix of ``_post``2119   - ProtectedMemberHungarianPrefix of ``On``2120 2121Identifies and/or transforms protected member names as follows:2122 2123Before:2124 2125.. code-block:: c++2126 2127    class Foo {2128    protected:2129      int Member_Variable;2130    }2131 2132After:2133 2134.. code-block:: c++2135 2136    class Foo {2137    protected:2138      int pre_member_variable_post;2139    }2140 2141.. option:: ProtectedMethodCase2142 2143    When defined, the check will ensure protected method names conform to the2144    selected casing.2145 2146.. option:: ProtectedMethodPrefix2147 2148    When defined, the check will ensure protected method names will add the2149    prefixed with the given value (regardless of casing).2150 2151.. option:: ProtectedMethodIgnoredRegexp2152 2153    Identifier naming checks won't be enforced for protected method names2154    matching this regular expression.2155 2156.. option:: ProtectedMethodSuffix2157 2158    When defined, the check will ensure protected method names will add the2159    suffix with the given value (regardless of casing).2160 2161For example using values of:2162 2163   - ProtectedMethodCase of ``lower_case``2164   - ProtectedMethodPrefix of ``pre_``2165   - ProtectedMethodSuffix of ``_post``2166 2167Identifies and/or transforms protect method names as follows:2168 2169Before:2170 2171.. code-block:: c++2172 2173    class Foo {2174    protected:2175      int Member_Method();2176    }2177 2178After:2179 2180.. code-block:: c++2181 2182    class Foo {2183    protected:2184      int pre_member_method_post();2185    }2186 2187.. option:: PublicMemberCase2188 2189    When defined, the check will ensure public member names conform to the2190    selected casing.2191 2192.. option:: PublicMemberPrefix2193 2194    When defined, the check will ensure public member names will add the2195    prefixed with the given value (regardless of casing).2196 2197.. option:: PublicMemberIgnoredRegexp2198 2199    Identifier naming checks won't be enforced for public member names2200    matching this regular expression.2201 2202.. option:: PublicMemberSuffix2203 2204    When defined, the check will ensure public member names will add the2205    suffix with the given value (regardless of casing).2206 2207.. option:: PublicMemberHungarianPrefix2208 2209    When enabled, the check ensures that the declared identifier will2210    have a Hungarian notation prefix based on the declared type.2211 2212For example using values of:2213 2214   - PublicMemberCase of ``lower_case``2215   - PublicMemberPrefix of ``pre_``2216   - PublicMemberSuffix of ``_post``2217   - PublicMemberHungarianPrefix of ``On``2218 2219Identifies and/or transforms public member names as follows:2220 2221Before:2222 2223.. code-block:: c++2224 2225    class Foo {2226    public:2227      int Member_Variable;2228    }2229 2230After:2231 2232.. code-block:: c++2233 2234    class Foo {2235    public:2236      int pre_member_variable_post;2237    }2238 2239.. option:: PublicMethodCase2240 2241    When defined, the check will ensure public method names conform to the2242    selected casing.2243 2244.. option:: PublicMethodPrefix2245 2246    When defined, the check will ensure public method names will add the2247    prefixed with the given value (regardless of casing).2248 2249.. option:: PublicMethodIgnoredRegexp2250 2251    Identifier naming checks won't be enforced for public method names2252    matching this regular expression.2253 2254.. option:: PublicMethodSuffix2255 2256    When defined, the check will ensure public method names will add the2257    suffix with the given value (regardless of casing).2258 2259For example using values of:2260 2261   - PublicMethodCase of ``lower_case``2262   - PublicMethodPrefix of ``pre_``2263   - PublicMethodSuffix of ``_post``2264 2265Identifies and/or transforms public method names as follows:2266 2267Before:2268 2269.. code-block:: c++2270 2271    class Foo {2272    public:2273      int Member_Method();2274    }2275 2276After:2277 2278.. code-block:: c++2279 2280    class Foo {2281    public:2282      int pre_member_method_post();2283    }2284 2285.. option:: ScopedEnumConstantCase2286 2287    When defined, the check will ensure scoped enum constant names conform to2288    the selected casing.2289 2290.. option:: ScopedEnumConstantPrefix2291 2292    When defined, the check will ensure scoped enum constant names will add the2293    prefixed with the given value (regardless of casing).2294 2295.. option:: ScopedEnumConstantIgnoredRegexp2296 2297    Identifier naming checks won't be enforced for scoped enum constant names2298    matching this regular expression.2299 2300.. option:: ScopedEnumConstantSuffix2301 2302    When defined, the check will ensure scoped enum constant names will add the2303    suffix with the given value (regardless of casing).2304 2305.. option:: ScopedEnumConstantHungarianPrefix2306 2307    When enabled, the check ensures that the declared identifier will2308    have a Hungarian notation prefix based on the declared type.2309 2310For example using values of:2311 2312   - ScopedEnumConstantCase of ``lower_case``2313   - ScopedEnumConstantPrefix of ``pre_``2314   - ScopedEnumConstantSuffix of ``_post``2315   - ScopedEnumConstantHungarianPrefix of ``On``2316 2317Identifies and/or transforms enumeration constant names as follows:2318 2319Before:2320 2321.. code-block:: c++2322 2323    enum class FOO { One, Two, Three };2324 2325After:2326 2327.. code-block:: c++2328 2329    enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };2330 2331.. option:: StaticConstexprVariableCase2332 2333    When defined, the check will ensure static ``constexpr`` variable names2334    conform to the selected casing.2335 2336.. option:: StaticConstexprVariablePrefix2337 2338    When defined, the check will ensure static ``constexpr`` variable names2339    will add the prefixed with the given value (regardless of casing).2340 2341.. option:: StaticConstexprVariableIgnoredRegexp2342 2343    Identifier naming checks won't be enforced for static ``constexpr``2344    variable names matching this regular expression.2345 2346.. option:: StaticConstexprVariableSuffix2347 2348    When defined, the check will ensure static ``constexpr`` variable names2349    will add the suffix with the given value (regardless of casing).2350 2351.. option:: StaticConstexprVariableHungarianPrefix2352 2353    When enabled, the check ensures that the declared identifier will have a2354    Hungarian notation prefix based on the declared type.2355 2356For example using values of:2357 2358   - StaticConstexprVariableCase of ``lower_case``2359   - StaticConstexprVariablePrefix of ``pre_``2360   - StaticConstexprVariableSuffix of ``_post``2361   - StaticConstexprVariableHungarianPrefix of ``On``2362 2363Identifies and/or transforms static ``constexpr`` variable names as follows:2364 2365Before:2366 2367.. code-block:: c++2368 2369    static unsigned constexpr MyConstexprStatic_array[] = {1, 2, 3};2370 2371After:2372 2373.. code-block:: c++2374 2375    static unsigned constexpr pre_my_constexpr_static_array_post[] = {1, 2, 3};2376 2377.. option:: StaticConstantCase2378 2379    When defined, the check will ensure static constant names conform to the2380    selected casing.2381 2382.. option:: StaticConstantPrefix2383 2384    When defined, the check will ensure static constant names will add the2385    prefixed with the given value (regardless of casing).2386 2387.. option:: StaticConstantIgnoredRegexp2388 2389    Identifier naming checks won't be enforced for static constant names2390    matching this regular expression.2391 2392.. option:: StaticConstantSuffix2393 2394    When defined, the check will ensure static constant names will add the2395    suffix with the given value (regardless of casing).2396 2397.. option:: StaticConstantHungarianPrefix2398 2399    When enabled, the check ensures that the declared identifier will2400    have a Hungarian notation prefix based on the declared type.2401 2402For example using values of:2403 2404   - StaticConstantCase of ``lower_case``2405   - StaticConstantPrefix of ``pre_``2406   - StaticConstantSuffix of ``_post``2407   - StaticConstantHungarianPrefix of ``On``2408 2409Identifies and/or transforms static constant names as follows:2410 2411Before:2412 2413.. code-block:: c++2414 2415    static unsigned const MyConstStatic_array[] = {1, 2, 3};2416 2417After:2418 2419.. code-block:: c++2420 2421    static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};2422 2423.. option:: StaticVariableCase2424 2425    When defined, the check will ensure static variable names conform to the2426    selected casing.2427 2428.. option:: StaticVariablePrefix2429 2430    When defined, the check will ensure static variable names will add the2431    prefixed with the given value (regardless of casing).2432 2433.. option:: StaticVariableIgnoredRegexp2434 2435    Identifier naming checks won't be enforced for static variable names2436    matching this regular expression.2437 2438.. option:: StaticVariableSuffix2439 2440    When defined, the check will ensure static variable names will add the2441    suffix with the given value (regardless of casing).2442 2443.. option:: StaticVariableHungarianPrefix2444 2445    When enabled, the check ensures that the declared identifier will2446    have a Hungarian notation prefix based on the declared type.2447 2448For example using values of:2449 2450   - StaticVariableCase of ``lower_case``2451   - StaticVariablePrefix of ``pre_``2452   - StaticVariableSuffix of ``_post``2453   - StaticVariableHungarianPrefix of ``On``2454 2455Identifies and/or transforms static variable names as follows:2456 2457Before:2458 2459.. code-block:: c++2460 2461    static unsigned MyStatic_array[] = {1, 2, 3};2462 2463After:2464 2465.. code-block:: c++2466 2467    static unsigned pre_mystatic_array_post[] = {1, 2, 3};2468 2469.. option:: StructCase2470 2471    When defined, the check will ensure struct names conform to the2472    selected casing.2473 2474.. option:: StructPrefix2475 2476    When defined, the check will ensure struct names will add the2477    prefixed with the given value (regardless of casing).2478 2479.. option:: StructIgnoredRegexp2480 2481    Identifier naming checks won't be enforced for struct names2482    matching this regular expression.2483 2484.. option:: StructSuffix2485 2486    When defined, the check will ensure struct names will add the2487    suffix with the given value (regardless of casing).2488 2489For example using values of:2490 2491   - StructCase of ``lower_case``2492   - StructPrefix of ``pre_``2493   - StructSuffix of ``_post``2494 2495Identifies and/or transforms struct names as follows:2496 2497Before:2498 2499.. code-block:: c++2500 2501    struct FOO {2502      FOO();2503      ~FOO();2504    };2505 2506After:2507 2508.. code-block:: c++2509 2510    struct pre_foo_post {2511      pre_foo_post();2512      ~pre_foo_post();2513    };2514 2515.. option:: TemplateParameterCase2516 2517    When defined, the check will ensure template parameter names conform to the2518    selected casing.2519 2520.. option:: TemplateParameterPrefix2521 2522    When defined, the check will ensure template parameter names will add the2523    prefixed with the given value (regardless of casing).2524 2525.. option:: TemplateParameterIgnoredRegexp2526 2527    Identifier naming checks won't be enforced for template parameter names2528    matching this regular expression.2529 2530.. option:: TemplateParameterSuffix2531 2532    When defined, the check will ensure template parameter names will add the2533    suffix with the given value (regardless of casing).2534 2535For example using values of:2536 2537   - TemplateParameterCase of ``lower_case``2538   - TemplateParameterPrefix of ``pre_``2539   - TemplateParameterSuffix of ``_post``2540 2541Identifies and/or transforms template parameter names as follows:2542 2543Before:2544 2545.. code-block:: c++2546 2547    template <typename T> class Foo {};2548 2549After:2550 2551.. code-block:: c++2552 2553    template <typename pre_t_post> class Foo {};2554 2555.. option:: TemplateTemplateParameterCase2556 2557    When defined, the check will ensure template template parameter names conform to the2558    selected casing.2559 2560.. option:: TemplateTemplateParameterPrefix2561 2562    When defined, the check will ensure template template parameter names will add the2563    prefixed with the given value (regardless of casing).2564 2565.. option:: TemplateTemplateParameterIgnoredRegexp2566 2567    Identifier naming checks won't be enforced for template template parameter2568    names matching this regular expression.2569 2570.. option:: TemplateTemplateParameterSuffix2571 2572    When defined, the check will ensure template template parameter names will add the2573    suffix with the given value (regardless of casing).2574 2575For example using values of:2576 2577   - TemplateTemplateParameterCase of ``lower_case``2578   - TemplateTemplateParameterPrefix of ``pre_``2579   - TemplateTemplateParameterSuffix of ``_post``2580 2581Identifies and/or transforms template template parameter names as follows:2582 2583Before:2584 2585.. code-block:: c++2586 2587    template <template <typename> class TPL_parameter, int COUNT_params,2588              typename... TYPE_parameters>2589 2590After:2591 2592.. code-block:: c++2593 2594    template <template <typename> class pre_tpl_parameter_post, int COUNT_params,2595              typename... TYPE_parameters>2596 2597.. option:: TypeAliasCase2598 2599    When defined, the check will ensure type alias names conform to the2600    selected casing.2601 2602.. option:: TypeAliasPrefix2603 2604    When defined, the check will ensure type alias names will add the2605    prefixed with the given value (regardless of casing).2606 2607.. option:: TypeAliasIgnoredRegexp2608 2609    Identifier naming checks won't be enforced for type alias names2610    matching this regular expression.2611 2612.. option:: TypeAliasSuffix2613 2614    When defined, the check will ensure type alias names will add the2615    suffix with the given value (regardless of casing).2616 2617For example using values of:2618 2619   - TypeAliasCase of ``lower_case``2620   - TypeAliasPrefix of ``pre_``2621   - TypeAliasSuffix of ``_post``2622 2623Identifies and/or transforms type alias names as follows:2624 2625Before:2626 2627.. code-block:: c++2628 2629    using MY_STRUCT_TYPE = my_structure;2630 2631After:2632 2633.. code-block:: c++2634 2635    using pre_my_struct_type_post = my_structure;2636 2637.. option:: TypedefCase2638 2639    When defined, the check will ensure typedef names conform to the2640    selected casing.2641 2642.. option:: TypedefPrefix2643 2644    When defined, the check will ensure typedef names will add the2645    prefixed with the given value (regardless of casing).2646 2647.. option:: TypedefIgnoredRegexp2648 2649    Identifier naming checks won't be enforced for typedef names2650    matching this regular expression.2651 2652.. option:: TypedefSuffix2653 2654    When defined, the check will ensure typedef names will add the2655    suffix with the given value (regardless of casing).2656 2657For example using values of:2658 2659   - TypedefCase of ``lower_case``2660   - TypedefPrefix of ``pre_``2661   - TypedefSuffix of ``_post``2662 2663Identifies and/or transforms typedef names as follows:2664 2665Before:2666 2667.. code-block:: c++2668 2669    typedef int MYINT;2670 2671After:2672 2673.. code-block:: c++2674 2675    typedef int pre_myint_post;2676 2677.. option:: TypeTemplateParameterCase2678 2679    When defined, the check will ensure type template parameter names conform to the2680    selected casing.2681 2682.. option:: TypeTemplateParameterPrefix2683 2684    When defined, the check will ensure type template parameter names will add the2685    prefixed with the given value (regardless of casing).2686 2687.. option:: TypeTemplateParameterIgnoredRegexp2688 2689    Identifier naming checks won't be enforced for type template names2690    matching this regular expression.2691 2692.. option:: TypeTemplateParameterSuffix2693 2694    When defined, the check will ensure type template parameter names will add the2695    suffix with the given value (regardless of casing).2696 2697For example using values of:2698 2699   - TypeTemplateParameterCase of ``lower_case``2700   - TypeTemplateParameterPrefix of ``pre_``2701   - TypeTemplateParameterSuffix of ``_post``2702 2703Identifies and/or transforms type template parameter names as follows:2704 2705Before:2706 2707.. code-block:: c++2708 2709    template <template <typename> class TPL_parameter, int COUNT_params,2710              typename... TYPE_parameters>2711 2712After:2713 2714.. code-block:: c++2715 2716    template <template <typename> class TPL_parameter, int COUNT_params,2717              typename... pre_type_parameters_post>2718 2719.. option:: UnionCase2720 2721    When defined, the check will ensure union names conform to the2722    selected casing.2723 2724.. option:: UnionPrefix2725 2726    When defined, the check will ensure union names will add the2727    prefixed with the given value (regardless of casing).2728 2729.. option:: UnionIgnoredRegexp2730 2731    Identifier naming checks won't be enforced for union names2732    matching this regular expression.2733 2734.. option:: UnionSuffix2735 2736    When defined, the check will ensure union names will add the2737    suffix with the given value (regardless of casing).2738 2739For example using values of:2740 2741   - UnionCase of ``lower_case``2742   - UnionPrefix of ``pre_``2743   - UnionSuffix of ``_post``2744 2745Identifies and/or transforms union names as follows:2746 2747Before:2748 2749.. code-block:: c++2750 2751    union FOO {2752      int a;2753      char b;2754    };2755 2756After:2757 2758.. code-block:: c++2759 2760    union pre_foo_post {2761      int a;2762      char b;2763    };2764 2765.. option:: ValueTemplateParameterCase2766 2767    When defined, the check will ensure value template parameter names conform to the2768    selected casing.2769 2770.. option:: ValueTemplateParameterPrefix2771 2772    When defined, the check will ensure value template parameter names will add the2773    prefixed with the given value (regardless of casing).2774 2775.. option:: ValueTemplateParameterIgnoredRegexp2776 2777    Identifier naming checks won't be enforced for value template parameter2778    names matching this regular expression.2779 2780.. option:: ValueTemplateParameterSuffix2781 2782    When defined, the check will ensure value template parameter names will add the2783    suffix with the given value (regardless of casing).2784 2785For example using values of:2786 2787   - ValueTemplateParameterCase of ``lower_case``2788   - ValueTemplateParameterPrefix of ``pre_``2789   - ValueTemplateParameterSuffix of ``_post``2790 2791Identifies and/or transforms value template parameter names as follows:2792 2793Before:2794 2795.. code-block:: c++2796 2797    template <template <typename> class TPL_parameter, int COUNT_params,2798              typename... TYPE_parameters>2799 2800After:2801 2802.. code-block:: c++2803 2804    template <template <typename> class TPL_parameter, int pre_count_params_post,2805              typename... TYPE_parameters>2806 2807.. option:: VariableCase2808 2809    When defined, the check will ensure variable names conform to the2810    selected casing.2811 2812.. option:: VariablePrefix2813 2814    When defined, the check will ensure variable names will add the2815    prefixed with the given value (regardless of casing).2816 2817.. option:: VariableIgnoredRegexp2818 2819    Identifier naming checks won't be enforced for variable names2820    matching this regular expression.2821 2822.. option:: VariableSuffix2823 2824    When defined, the check will ensure variable names will add the2825    suffix with the given value (regardless of casing).2826 2827.. option:: VariableHungarianPrefix2828 2829    When enabled, the check ensures that the declared identifier will2830    have a Hungarian notation prefix based on the declared type.2831 2832For example using values of:2833 2834   - VariableCase of ``lower_case``2835   - VariablePrefix of ``pre_``2836   - VariableSuffix of ``_post``2837   - VariableHungarianPrefix of ``On``2838 2839Identifies and/or transforms variable names as follows:2840 2841Before:2842 2843.. code-block:: c++2844 2845    unsigned MyVariable;2846 2847After:2848 2849.. code-block:: c++2850 2851    unsigned pre_myvariable_post;2852 2853.. option:: VirtualMethodCase2854 2855    When defined, the check will ensure virtual method names conform to the2856    selected casing.2857 2858.. option:: VirtualMethodPrefix2859 2860    When defined, the check will ensure virtual method names will add the2861    prefixed with the given value (regardless of casing).2862 2863.. option:: VirtualMethodIgnoredRegexp2864 2865    Identifier naming checks won't be enforced for virtual method names2866    matching this regular expression.2867 2868.. option:: VirtualMethodSuffix2869 2870    When defined, the check will ensure virtual method names will add the2871    suffix with the given value (regardless of casing).2872 2873For example using values of:2874 2875   - VirtualMethodCase of ``lower_case``2876   - VirtualMethodPrefix of ``pre_``2877   - VirtualMethodSuffix of ``_post``2878 2879Identifies and/or transforms virtual method names as follows:2880 2881Before:2882 2883.. code-block:: c++2884 2885    class Foo {2886    public:2887      virtual int MemberFunction();2888    }2889 2890After:2891 2892.. code-block:: c++2893 2894    class Foo {2895    public:2896      virtual int pre_member_function_post();2897    }2898 2899 2900The default mapping table of Hungarian Notation2901-----------------------------------------------2902 2903In Hungarian notation, a variable name starts with a group of lower-case2904letters which are mnemonics for the type or purpose of that variable, followed2905by whatever name the programmer has chosen; this last part is sometimes2906distinguished as the given name. The first character of the given name can be2907capitalized to separate it from the type indicators (see also CamelCase).2908Otherwise the case of this character denotes scope.2909 2910The following table is the default mapping table of Hungarian Notation2911which maps Decl to its prefix string. You can also have your own style2912in config file.2913 2914============== ======== ====================== ======== ============== ========2915Primitive Type                                          Microsoft Type2916-------------- -------- ---------------------- -------- -------------- --------2917    Type       Prefix   Type                   Prefix   Type           Prefix2918============== ======== ====================== ======== ============== ========2919int8_t         i8       signed int             si       BOOL           b2920int16_t        i16      signed short           ss       BOOLEAN        b2921int32_t        i32      signed short int       ssi      BYTE           by2922int64_t        i64      signed long long int   slli     CHAR           c2923uint8_t        u8       signed long long       sll      UCHAR          uc2924uint16_t       u16      signed long int        sli      SHORT          s2925uint32_t       u32      signed long            sl       USHORT         us2926uint64_t       u64      signed                 s        WORD           w2927char8_t        c8       unsigned long long int ulli     DWORD          dw2928char16_t       c16      unsigned long long     ull      DWORD32        dw322929char32_t       c32      unsigned long int      uli      DWORD64        dw642930float          f        unsigned long          ul       LONG           l2931double         d        unsigned short int     usi      ULONG          ul2932char           c        unsigned short         us       ULONG32        ul322933bool           b        unsigned int           ui       ULONG64        ul642934_Bool          b        unsigned char          uc       ULONGLONG      ull2935int            i        unsigned               u        HANDLE         h2936size_t         n        long long int          lli      INT            i2937short          s        long double            ld       INT8           i82938signed         i        long long              ll       INT16          i162939unsigned       u        long int               li       INT32          i322940long           l        long                   l        INT64          i642941long long      ll       ptrdiff_t              p        UINT           ui2942unsigned long  ul       void                   *none*   UINT8          u82943long double    ld                                       UINT16         u162944ptrdiff_t      p                                        UINT32         u322945wchar_t        wc                                       UINT64         u642946short int      si                                       PVOID          p2947short          s2948============== ======== ====================== ======== ============== ========2949 2950**There are more trivial options for Hungarian Notation:**2951 2952**HungarianNotation.General.***2953  Options are not belonging to any specific Decl.2954 2955**HungarianNotation.CString.***2956  Options for NULL-terminated string.2957 2958**HungarianNotation.DerivedType.***2959 Options for derived types.2960 2961**HungarianNotation.PrimitiveType.***2962  Options for primitive types.2963 2964**HungarianNotation.UserDefinedType.***2965  Options for user-defined types.2966 2967 2968Options for Hungarian Notation2969------------------------------2970 2971- :option:`HungarianNotation.General.TreatStructAsClass`2972 2973- :option:`HungarianNotation.DerivedType.Array`2974- :option:`HungarianNotation.DerivedType.Pointer`2975- :option:`HungarianNotation.DerivedType.FunctionPointer`2976 2977- :option:`HungarianNotation.CString.CharPointer`2978- :option:`HungarianNotation.CString.CharArray`2979- :option:`HungarianNotation.CString.WideCharPointer`2980- :option:`HungarianNotation.CString.WideCharArray`2981 2982- :option:`HungarianNotation.PrimitiveType.*`2983- :option:`HungarianNotation.UserDefinedType.*`2984 2985.. option:: HungarianNotation.General.TreatStructAsClass2986 2987    When defined, the check will treat naming of struct as a class.2988    The default value is `false`.2989 2990.. option:: HungarianNotation.DerivedType.Array2991 2992    When defined, the check will ensure variable name will add the prefix with2993    the given string. The default prefix is `a`.2994 2995.. option:: HungarianNotation.DerivedType.Pointer2996 2997    When defined, the check will ensure variable name will add the prefix with2998    the given string. The default prefix is `p`.2999 3000.. option:: HungarianNotation.DerivedType.FunctionPointer3001 3002    When defined, the check will ensure variable name will add the prefix with3003    the given string. The default prefix is `fn`.3004 3005 3006Before:3007 3008.. code-block:: c++3009 3010    // Array3011    int DataArray[2] = {0};3012 3013    // Pointer3014    void *DataBuffer = NULL;3015 3016    // FunctionPointer3017    typedef void (*FUNC_PTR)();3018    FUNC_PTR FuncPtr = NULL;3019 3020After:3021 3022.. code-block:: c++3023 3024    // Array3025    int aDataArray[2] = {0};3026 3027    // Pointer3028    void *pDataBuffer = NULL;3029 3030    // FunctionPointer3031    typedef void (*FUNC_PTR)();3032    FUNC_PTR fnFuncPtr = NULL;3033 3034 3035.. option:: HungarianNotation.CString.CharPointer3036 3037    When defined, the check will ensure variable name will add the prefix with3038    the given string. The default prefix is `sz`.3039 3040.. option:: HungarianNotation.CString.CharArray3041 3042    When defined, the check will ensure variable name will add the prefix with3043    the given string. The default prefix is `sz`.3044 3045.. option:: HungarianNotation.CString.WideCharPointer3046 3047    When defined, the check will ensure variable name will add the prefix with3048    the given string. The default prefix is `wsz`.3049 3050.. option:: HungarianNotation.CString.WideCharArray3051 3052    When defined, the check will ensure variable name will add the prefix with3053    the given string. The default prefix is `wsz`.3054 3055 3056Before:3057 3058.. code-block:: c++3059 3060    // CharPointer3061    const char *NamePtr = "Name";3062 3063    // CharArray3064    const char NameArray[] = "Name";3065 3066    // WideCharPointer3067    const wchar_t *WideNamePtr = L"Name";3068 3069    // WideCharArray3070    const wchar_t WideNameArray[] = L"Name";3071 3072After:3073 3074.. code-block:: c++3075 3076    // CharPointer3077    const char *szNamePtr = "Name";3078 3079    // CharArray3080    const char szNameArray[] = "Name";3081 3082    // WideCharPointer3083    const wchar_t *wszWideNamePtr = L"Name";3084 3085    // WideCharArray3086    const wchar_t wszWideNameArray[] = L"Name";3087 3088 3089.. option:: HungarianNotation.PrimitiveType.*3090 3091    When defined, the check will ensure variable name of involved primitive3092    types will add the prefix with the given string. The default prefixes are3093    defined in the default mapping table.3094 3095.. option:: HungarianNotation.UserDefinedType.*3096 3097    When defined, the check will ensure variable name of involved primitive3098    types will add the prefix with the given string. The default prefixes are3099    defined in the default mapping table.3100 3101 3102Before:3103 3104.. code-block:: c++3105 3106    int8_t   ValueI8      = 0;3107    int16_t  ValueI16     = 0;3108    int32_t  ValueI32     = 0;3109    int64_t  ValueI64     = 0;3110    uint8_t  ValueU8      = 0;3111    uint16_t ValueU16     = 0;3112    uint32_t ValueU32     = 0;3113    uint64_t ValueU64     = 0;3114    float    ValueFloat   = 0.0;3115    double   ValueDouble  = 0.0;3116    ULONG    ValueUlong   = 0;3117    DWORD    ValueDword   = 0;3118 3119After:3120 3121.. code-block:: c++3122 3123    int8_t   i8ValueI8    = 0;3124    int16_t  i16ValueI16  = 0;3125    int32_t  i32ValueI32  = 0;3126    int64_t  i64ValueI64  = 0;3127    uint8_t  u8ValueU8    = 0;3128    uint16_t u16ValueU16  = 0;3129    uint32_t u32ValueU32  = 0;3130    uint64_t u64ValueU64  = 0;3131    float    fValueFloat  = 0.0;3132    double   dValueDouble = 0.0;3133    ULONG    ulValueUlong = 0;3134    DWORD    dwValueDword = 0;3135