1.. title:: clang-tidy - readability-identifier-naming 2 3readability-identifier-naming 4============================= 5 6Checks for identifiers naming style mismatch. 7 8This check will try to enforce coding guidelines on the identifiers naming. It 9supports one of the following casing types and tries to convert from one to 10another if a mismatch is detected 11 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 22It also supports a fixed prefix and suffix that will be prepended or appended 23to the identifiers, regardless of the casing. 24 25Many configuration options are available, in order to be able to create 26different rules for different kinds of identifiers. In general, the rules are 27falling back to a more generic rule if the specific case is not configured. 28 29The naming of virtual methods is reported where they occur in the base class, 30but not where they are overridden, as it can't be fixed locally there. 31This also applies for pseudo-override patterns like CRTP. 32 33Options 34------- 35 36The following options are describe below: 37 38 - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`, :option:`AbstractClassSuffix` 39 - :option:`AggressiveDependentMemberLookup` 40 - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix` 41 - :option:`ClassConstantCase`, :option:`ClassConstantPrefix`, :option:`ClassConstantSuffix` 42 - :option:`ClassMemberCase`, :option:`ClassMemberPrefix`, :option:`ClassMemberSuffix` 43 - :option:`ClassMethodCase`, :option:`ClassMethodPrefix`, :option:`ClassMethodSuffix` 44 - :option:`ConstantCase`, :option:`ConstantPrefix`, :option:`ConstantSuffix` 45 - :option:`ConstantMemberCase`, :option:`ConstantMemberPrefix`, :option:`ConstantMemberSuffix` 46 - :option:`ConstantParameterCase`, :option:`ConstantParameterPrefix`, :option:`ConstantParameterSuffix` 47 - :option:`ConstantPointerParameterCase`, :option:`ConstantPointerParameterPrefix`, :option:`ConstantPointerParameterSuffix` 48 - :option:`ConstexprFunctionCase`, :option:`ConstexprFunctionPrefix`, :option:`ConstexprFunctionSuffix` 49 - :option:`ConstexprMethodCase`, :option:`ConstexprMethodPrefix`, :option:`ConstexprMethodSuffix` 50 - :option:`ConstexprVariableCase`, :option:`ConstexprVariablePrefix`, :option:`ConstexprVariableSuffix` 51 - :option:`EnumCase`, :option:`EnumPrefix`, :option:`EnumSuffix` 52 - :option:`EnumConstantCase`, :option:`EnumConstantPrefix`, :option:`EnumConstantSuffix` 53 - :option:`FunctionCase`, :option:`FunctionPrefix`, :option:`FunctionSuffix` 54 - :option:`GlobalConstantCase`, :option:`GlobalConstantPrefix`, :option:`GlobalConstantSuffix` 55 - :option:`GlobalConstantPointerCase`, :option:`GlobalConstantPointerPrefix`, :option:`GlobalConstantPointerSuffix` 56 - :option:`GlobalFunctionCase`, :option:`GlobalFunctionPrefix`, :option:`GlobalFunctionSuffix` 57 - :option:`GlobalPointerCase`, :option:`GlobalPointerPrefix`, :option:`GlobalPointerSuffix` 58 - :option:`GlobalVariableCase`, :option:`GlobalVariablePrefix`, :option:`GlobalVariableSuffix` 59 - :option:`IgnoreMainLikeFunctions` 60 - :option:`InlineNamespaceCase`, :option:`InlineNamespacePrefix`, :option:`InlineNamespaceSuffix` 61 - :option:`LocalConstantCase`, :option:`LocalConstantPrefix`, :option:`LocalConstantSuffix` 62 - :option:`LocalConstantPointerCase`, :option:`LocalConstantPointerPrefix`, :option:`LocalConstantPointerSuffix` 63 - :option:`LocalPointerCase`, :option:`LocalPointerPrefix`, :option:`LocalPointerSuffix` 64 - :option:`LocalVariableCase`, :option:`LocalVariablePrefix`, :option:`LocalVariableSuffix` 65 - :option:`MacroDefinitionCase`, :option:`MacroDefinitionPrefix`, :option:`MacroDefinitionSuffix` 66 - :option:`MemberCase`, :option:`MemberPrefix`, :option:`MemberSuffix` 67 - :option:`MethodCase`, :option:`MethodPrefix`, :option:`MethodSuffix` 68 - :option:`NamespaceCase`, :option:`NamespacePrefix`, :option:`NamespaceSuffix` 69 - :option:`ParameterCase`, :option:`ParameterPrefix`, :option:`ParameterSuffix` 70 - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix` 71 - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix` 72 - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix` 73 - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix` 74 - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix` 75 - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix` 76 - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix` 77 - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`, :option:`PublicMethodSuffix` 78 - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix` 79 - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix` 80 - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix` 81 - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`, :option:`TemplateParameterSuffix` 82 - :option:`TemplateTemplateParameterCase`, :option:`TemplateTemplateParameterPrefix`, :option:`TemplateTemplateParameterSuffix` 83 - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`, :option:`TypeAliasSuffix` 84 - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix` 85 - :option:`TypeTemplateParameterCase`, :option:`TypeTemplateParameterPrefix`, :option:`TypeTemplateParameterSuffix` 86 - :option:`UnionCase`, :option:`UnionPrefix`, :option:`UnionSuffix` 87 - :option:`ValueTemplateParameterCase`, :option:`ValueTemplateParameterPrefix`, :option:`ValueTemplateParameterSuffix` 88 - :option:`VariableCase`, :option:`VariablePrefix`, :option:`VariableSuffix` 89 - :option:`VirtualMethodCase`, :option:`VirtualMethodPrefix`, :option:`VirtualMethodSuffix` 90 91.. option:: AbstractClassCase 92 93 When defined, the check will ensure abstract class names conform to the 94 selected casing. 95 96.. option:: AbstractClassPrefix 97 98 When defined, the check will ensure abstract class names will add the 99 prefixed with the given value (regardless of casing). 100 101.. option:: AbstractClassSuffix 102 103 When defined, the check will ensure abstract class names will add the 104 suffix with the given value (regardless of casing). 105 106For example using values of: 107 108 - AbstractClassCase of ``lower_case`` 109 - AbstractClassPrefix of ``pre_`` 110 - AbstractClassSuffix of ``_post`` 111 112Identifies and/or transforms abstract class names as follows: 113 114Before: 115 116.. code-block:: c++ 117 118 class ABSTRACT_CLASS { 119 public: 120 ABSTRACT_CLASS(); 121 }; 122 123After: 124 125.. code-block:: c++ 126 127 class pre_abstract_class_post { 128 public: 129 pre_abstract_class_post(); 130 }; 131 132.. option:: AggressiveDependentMemberLookup 133 134 When set to `1` the check will look in dependent base classes for dependent 135 member references that need changing. This can lead to errors with template 136 specializations so the default value is `0`. 137 138For example using values of: 139 140 - ClassMemberCase of ``lower_case`` 141 142Before: 143 144.. code-block:: c++ 145 146 template <typename T> 147 struct Base { 148 T BadNamedMember; 149 }; 150 151 template <typename T> 152 struct Derived : Base<T> { 153 void reset() { 154 this->BadNamedMember = 0; 155 } 156 }; 157 158After if AggressiveDependentMemberLookup is ``0``: 159 160.. code-block:: c++ 161 162 template <typename T> 163 struct Base { 164 T bad_named_member; 165 }; 166 167 template <typename T> 168 struct Derived : Base<T> { 169 void reset() { 170 this->BadNamedMember = 0; 171 } 172 }; 173 174After if AggressiveDependentMemberLookup is ``1``: 175 176.. code-block:: c++ 177 178 template <typename T> 179 struct Base { 180 T bad_named_member; 181 }; 182 183 template <typename T> 184 struct Derived : Base<T> { 185 void reset() { 186 this->bad_named_member = 0; 187 } 188 }; 189 190.. option:: ClassCase 191 192 When defined, the check will ensure class names conform to the 193 selected casing. 194 195.. option:: ClassPrefix 196 197 When defined, the check will ensure class names will add the 198 prefixed with the given value (regardless of casing). 199 200.. option:: ClassSuffix 201 202 When defined, the check will ensure class names will add the 203 suffix with the given value (regardless of casing). 204 205For example using values of: 206 207 - ClassCase of ``lower_case`` 208 - ClassPrefix of ``pre_`` 209 - ClassSuffix of ``_post`` 210 211Identifies and/or transforms class names as follows: 212 213Before: 214 215.. code-block:: c++ 216 217 class FOO { 218 public: 219 FOO(); 220 ~FOO(); 221 }; 222 223After: 224 225.. code-block:: c++ 226 227 class pre_foo_post { 228 public: 229 pre_foo_post(); 230 ~pre_foo_post(); 231 }; 232 233.. option:: ClassConstantCase 234 235 When defined, the check will ensure class constant names conform to the 236 selected casing. 237 238.. option:: ClassConstantPrefix 239 240 When defined, the check will ensure class constant names will add the 241 prefixed with the given value (regardless of casing). 242 243.. option:: ClassConstantSuffix 244 245 When defined, the check will ensure class constant names will add the 246 suffix with the given value (regardless of casing). 247 248For example using values of: 249 250 - ClassConstantCase of ``lower_case`` 251 - ClassConstantPrefix of ``pre_`` 252 - ClassConstantSuffix of ``_post`` 253 254Identifies and/or transforms class constant names as follows: 255 256Before: 257 258.. code-block:: c++ 259 260 class FOO { 261 public: 262 static const int CLASS_CONSTANT; 263 }; 264 265After: 266 267.. code-block:: c++ 268 269 class FOO { 270 public: 271 static const int pre_class_constant_post; 272 }; 273 274.. option:: ClassMemberCase 275 276 When defined, the check will ensure class member names conform to the 277 selected casing. 278 279.. option:: ClassMemberPrefix 280 281 When defined, the check will ensure class member names will add the 282 prefixed with the given value (regardless of casing). 283 284.. option:: ClassMemberSuffix 285 286 When defined, the check will ensure class member names will add the 287 suffix with the given value (regardless of casing). 288 289For example using values of: 290 291 - ClassMemberCase of ``lower_case`` 292 - ClassMemberPrefix of ``pre_`` 293 - ClassMemberSuffix of ``_post`` 294 295Identifies and/or transforms class member names as follows: 296 297Before: 298 299.. code-block:: c++ 300 301 class FOO { 302 public: 303 static int CLASS_CONSTANT; 304 }; 305 306After: 307 308.. code-block:: c++ 309 310 class FOO { 311 public: 312 static int pre_class_constant_post; 313 }; 314 315.. option:: ClassMethodCase 316 317 When defined, the check will ensure class method names conform to the 318 selected casing. 319 320.. option:: ClassMethodPrefix 321 322 When defined, the check will ensure class method names will add the 323 prefixed with the given value (regardless of casing). 324 325.. option:: ClassMethodSuffix 326 327 When defined, the check will ensure class method names will add the 328 suffix with the given value (regardless of casing). 329 330For example using values of: 331 332 - ClassMethodCase of ``lower_case`` 333 - ClassMethodPrefix of ``pre_`` 334 - ClassMethodSuffix of ``_post`` 335 336Identifies and/or transforms class method names as follows: 337 338Before: 339 340.. code-block:: c++ 341 342 class FOO { 343 public: 344 int CLASS_MEMBER(); 345 }; 346 347After: 348 349.. code-block:: c++ 350 351 class FOO { 352 public: 353 int pre_class_member_post(); 354 }; 355 356.. option:: ConstantCase 357 358 When defined, the check will ensure constant names conform to the 359 selected casing. 360 361.. option:: ConstantPrefix 362 363 When defined, the check will ensure constant names will add the 364 prefixed with the given value (regardless of casing). 365 366.. option:: ConstantSuffix 367 368 When defined, the check will ensure constant names will add the 369 suffix with the given value (regardless of casing). 370 371For example using values of: 372 373 - ConstantCase of ``lower_case`` 374 - ConstantPrefix of ``pre_`` 375 - ConstantSuffix of ``_post`` 376 377Identifies and/or transforms constant names as follows: 378 379Before: 380 381.. code-block:: c++ 382 383 void function() { unsigned const MyConst_array[] = {1, 2, 3}; } 384 385After: 386 387.. code-block:: c++ 388 389 void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; } 390 391.. option:: ConstantMemberCase 392 393 When defined, the check will ensure constant member names conform to the 394 selected casing. 395 396.. option:: ConstantMemberPrefix 397 398 When defined, the check will ensure constant member names will add the 399 prefixed with the given value (regardless of casing). 400 401.. option:: ConstantMemberSuffix 402 403 When defined, the check will ensure constant member names will add the 404 suffix with the given value (regardless of casing). 405 406For example using values of: 407 408 - ConstantMemberCase of ``lower_case`` 409 - ConstantMemberPrefix of ``pre_`` 410 - ConstantMemberSuffix of ``_post`` 411 412Identifies and/or transforms constant member names as follows: 413 414Before: 415 416.. code-block:: c++ 417 418 class Foo { 419 char const MY_ConstMember_string[4] = "123"; 420 } 421 422After: 423 424.. code-block:: c++ 425 426 class Foo { 427 char const pre_my_constmember_string_post[4] = "123"; 428 } 429 430.. option:: ConstantParameterCase 431 432 When defined, the check will ensure constant parameter names conform to the 433 selected casing. 434 435.. option:: ConstantParameterPrefix 436 437 When defined, the check will ensure constant parameter names will add the 438 prefixed with the given value (regardless of casing). 439 440.. option:: ConstantParameterSuffix 441 442 When defined, the check will ensure constant parameter names will add the 443 suffix with the given value (regardless of casing). 444 445For example using values of: 446 447 - ConstantParameterCase of ``lower_case`` 448 - ConstantParameterPrefix of ``pre_`` 449 - ConstantParameterSuffix of ``_post`` 450 451Identifies and/or transforms constant parameter names as follows: 452 453Before: 454 455.. code-block:: c++ 456 457 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter); 458 459After: 460 461.. code-block:: c++ 462 463 void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post); 464 465.. option:: ConstantPointerParameterCase 466 467 When defined, the check will ensure constant pointer parameter names conform to the 468 selected casing. 469 470.. option:: ConstantPointerParameterPrefix 471 472 When defined, the check will ensure constant pointer parameter names will add the 473 prefixed with the given value (regardless of casing). 474 475.. option:: ConstantPointerParameterSuffix 476 477 When defined, the check will ensure constant pointer parameter names will add the 478 suffix with the given value (regardless of casing). 479 480For example using values of: 481 482 - ConstantPointerParameterCase of ``lower_case`` 483 - ConstantPointerParameterPrefix of ``pre_`` 484 - ConstantPointerParameterSuffix of ``_post`` 485 486Identifies and/or transforms constant pointer parameter names as follows: 487 488Before: 489 490.. code-block:: c++ 491 492 void GLOBAL_FUNCTION(int const *CONST_parameter); 493 494After: 495 496.. code-block:: c++ 497 498 void GLOBAL_FUNCTION(int const *pre_const_parameter_post); 499 500.. option:: ConstexprFunctionCase 501 502 When defined, the check will ensure constexpr function names conform to the 503 selected casing. 504 505.. option:: ConstexprFunctionPrefix 506 507 When defined, the check will ensure constexpr function names will add the 508 prefixed with the given value (regardless of casing). 509 510.. option:: ConstexprFunctionSuffix 511 512 When defined, the check will ensure constexpr function names will add the 513 suffix with the given value (regardless of casing). 514 515For example using values of: 516 517 - ConstexprFunctionCase of ``lower_case`` 518 - ConstexprFunctionPrefix of ``pre_`` 519 - ConstexprFunctionSuffix of ``_post`` 520 521Identifies and/or transforms constexpr function names as follows: 522 523Before: 524 525.. code-block:: c++ 526 527 constexpr int CE_function() { return 3; } 528 529After: 530 531.. code-block:: c++ 532 533 constexpr int pre_ce_function_post() { return 3; } 534 535.. option:: ConstexprMethodCase 536 537 When defined, the check will ensure constexpr method names conform to the 538 selected casing. 539 540.. option:: ConstexprMethodPrefix 541 542 When defined, the check will ensure constexpr method names will add the 543 prefixed with the given value (regardless of casing). 544 545.. option:: ConstexprMethodSuffix 546 547 When defined, the check will ensure constexpr method names will add the 548 suffix with the given value (regardless of casing). 549 550For example using values of: 551 552 - ConstexprMethodCase of ``lower_case`` 553 - ConstexprMethodPrefix of ``pre_`` 554 - ConstexprMethodSuffix of ``_post`` 555 556Identifies and/or transforms constexpr method names as follows: 557 558Before: 559 560.. code-block:: c++ 561 562 class Foo { 563 public: 564 constexpr int CST_expr_Method() { return 2; } 565 } 566 567After: 568 569.. code-block:: c++ 570 571 class Foo { 572 public: 573 constexpr int pre_cst_expr_method_post() { return 2; } 574 } 575 576.. option:: ConstexprVariableCase 577 578 When defined, the check will ensure constexpr variable names conform to the 579 selected casing. 580 581.. option:: ConstexprVariablePrefix 582 583 When defined, the check will ensure constexpr variable names will add the 584 prefixed with the given value (regardless of casing). 585 586.. option:: ConstexprVariableSuffix 587 588 When defined, the check will ensure constexpr variable names will add the 589 suffix with the given value (regardless of casing). 590 591For example using values of: 592 593 - ConstexprVariableCase of ``lower_case`` 594 - ConstexprVariablePrefix of ``pre_`` 595 - ConstexprVariableSuffix of ``_post`` 596 597Identifies and/or transforms constexpr variable names as follows: 598 599Before: 600 601.. code-block:: c++ 602 603 constexpr int ConstExpr_variable = MyConstant; 604 605After: 606 607.. code-block:: c++ 608 609 constexpr int pre_constexpr_variable_post = MyConstant; 610 611.. option:: EnumCase 612 613 When defined, the check will ensure enumeration names conform to the 614 selected casing. 615 616.. option:: EnumPrefix 617 618 When defined, the check will ensure enumeration names will add the 619 prefixed with the given value (regardless of casing). 620 621.. option:: EnumSuffix 622 623 When defined, the check will ensure enumeration names will add the 624 suffix with the given value (regardless of casing). 625 626For example using values of: 627 628 - EnumCase of ``lower_case`` 629 - EnumPrefix of ``pre_`` 630 - EnumSuffix of ``_post`` 631 632Identifies and/or transforms enumeration names as follows: 633 634Before: 635 636.. code-block:: c++ 637 638 enum FOO { One, Two, Three }; 639 640After: 641 642.. code-block:: c++ 643 644 enum pre_foo_post { One, Two, Three }; 645 646.. option:: EnumConstantCase 647 648 When defined, the check will ensure enumeration constant names conform to the 649 selected casing. 650 651.. option:: EnumConstantPrefix 652 653 When defined, the check will ensure enumeration constant names will add the 654 prefixed with the given value (regardless of casing). 655 656.. option:: EnumConstantSuffix 657 658 When defined, the check will ensure enumeration constant names will add the 659 suffix with the given value (regardless of casing). 660 661For example using values of: 662 663 - EnumConstantCase of ``lower_case`` 664 - EnumConstantPrefix of ``pre_`` 665 - EnumConstantSuffix of ``_post`` 666 667Identifies and/or transforms enumeration constant names as follows: 668 669Before: 670 671.. code-block:: c++ 672 673 enum FOO { One, Two, Three }; 674 675After: 676 677.. code-block:: c++ 678 679 enum FOO { pre_One_post, pre_Two_post, pre_Three_post }; 680 681.. option:: FunctionCase 682 683 When defined, the check will ensure function names conform to the 684 selected casing. 685 686.. option:: FunctionPrefix 687 688 When defined, the check will ensure function names will add the 689 prefixed with the given value (regardless of casing). 690 691.. option:: FunctionSuffix 692 693 When defined, the check will ensure function names will add the 694 suffix with the given value (regardless of casing). 695 696For example using values of: 697 698 - FunctionCase of ``lower_case`` 699 - FunctionPrefix of ``pre_`` 700 - FunctionSuffix of ``_post`` 701 702Identifies and/or transforms function names as follows: 703 704Before: 705 706.. code-block:: c++ 707 708 char MY_Function_string(); 709 710After: 711 712.. code-block:: c++ 713 714 char pre_my_function_string_post(); 715 716.. option:: GlobalConstantCase 717 718 When defined, the check will ensure global constant names conform to the 719 selected casing. 720 721.. option:: GlobalConstantPrefix 722 723 When defined, the check will ensure global constant names will add the 724 prefixed with the given value (regardless of casing). 725 726.. option:: GlobalConstantSuffix 727 728 When defined, the check will ensure global constant names will add the 729 suffix with the given value (regardless of casing). 730 731For example using values of: 732 733 - GlobalConstantCase of ``lower_case`` 734 - GlobalConstantPrefix of ``pre_`` 735 - GlobalConstantSuffix of ``_post`` 736 737Identifies and/or transforms global constant names as follows: 738 739Before: 740 741.. code-block:: c++ 742 743 unsigned const MyConstGlobal_array[] = {1, 2, 3}; 744 745After: 746 747.. code-block:: c++ 748 749 unsigned const pre_myconstglobal_array_post[] = {1, 2, 3}; 750 751.. option:: GlobalConstantPointerCase 752 753 When defined, the check will ensure global constant pointer names conform to the 754 selected casing. 755 756.. option:: GlobalConstantPointerPrefix 757 758 When defined, the check will ensure global constant pointer names will add the 759 prefixed with the given value (regardless of casing). 760 761.. option:: GlobalConstantPointerSuffix 762 763 When defined, the check will ensure global constant pointer names will add the 764 suffix with the given value (regardless of casing). 765 766For example using values of: 767 768 - GlobalConstantPointerCase of ``lower_case`` 769 - GlobalConstantPointerPrefix of ``pre_`` 770 - GlobalConstantPointerSuffix of ``_post`` 771 772Identifies and/or transforms global constant pointer names as follows: 773 774Before: 775 776.. code-block:: c++ 777 778 int *const MyConstantGlobalPointer = nullptr; 779 780After: 781 782.. code-block:: c++ 783 784 int *const pre_myconstantglobalpointer_post = nullptr; 785 786.. option:: GlobalFunctionCase 787 788 When defined, the check will ensure global function names conform to the 789 selected casing. 790 791.. option:: GlobalFunctionPrefix 792 793 When defined, the check will ensure global function names will add the 794 prefixed with the given value (regardless of casing). 795 796.. option:: GlobalFunctionSuffix 797 798 When defined, the check will ensure global function names will add the 799 suffix with the given value (regardless of casing). 800 801For example using values of: 802 803 - GlobalFunctionCase of ``lower_case`` 804 - GlobalFunctionPrefix of ``pre_`` 805 - GlobalFunctionSuffix of ``_post`` 806 807Identifies and/or transforms global function names as follows: 808 809Before: 810 811.. code-block:: c++ 812 813 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter); 814 815After: 816 817.. code-block:: c++ 818 819 void pre_global_function_post(int PARAMETER_1, int const CONST_parameter); 820 821.. option:: GlobalPointerCase 822 823 When defined, the check will ensure global pointer names conform to the 824 selected casing. 825 826.. option:: GlobalPointerPrefix 827 828 When defined, the check will ensure global pointer names will add the 829 prefixed with the given value (regardless of casing). 830 831.. option:: GlobalPointerSuffix 832 833 When defined, the check will ensure global pointer names will add the 834 suffix with the given value (regardless of casing). 835 836For example using values of: 837 838 - GlobalPointerCase of ``lower_case`` 839 - GlobalPointerPrefix of ``pre_`` 840 - GlobalPointerSuffix of ``_post`` 841 842Identifies and/or transforms global pointer names as follows: 843 844Before: 845 846.. code-block:: c++ 847 848 int *GLOBAL3; 849 850After: 851 852.. code-block:: c++ 853 854 int *pre_global3_post; 855 856.. option:: GlobalVariableCase 857 858 When defined, the check will ensure global variable names conform to the 859 selected casing. 860 861.. option:: GlobalVariablePrefix 862 863 When defined, the check will ensure global variable names will add the 864 prefixed with the given value (regardless of casing). 865 866.. option:: GlobalVariableSuffix 867 868 When defined, the check will ensure global variable names will add the 869 suffix with the given value (regardless of casing). 870 871For example using values of: 872 873 - GlobalVariableCase of ``lower_case`` 874 - GlobalVariablePrefix of ``pre_`` 875 - GlobalVariableSuffix of ``_post`` 876 877Identifies and/or transforms global variable names as follows: 878 879Before: 880 881.. code-block:: c++ 882 883 int GLOBAL3; 884 885After: 886 887.. code-block:: c++ 888 889 int pre_global3_post; 890 891.. option:: IgnoreMainLikeFunctions 892 893 When set to `1` functions that have a similar signature to ``main`` or 894 ``wmain`` won't enforce checks on the names of their parameters. 895 Default value is `0`. 896 897.. option:: InlineNamespaceCase 898 899 When defined, the check will ensure inline namespaces names conform to the 900 selected casing. 901 902.. option:: InlineNamespacePrefix 903 904 When defined, the check will ensure inline namespaces names will add the 905 prefixed with the given value (regardless of casing). 906 907.. option:: InlineNamespaceSuffix 908 909 When defined, the check will ensure inline namespaces names will add the 910 suffix with the given value (regardless of casing). 911 912For example using values of: 913 914 - InlineNamespaceCase of ``lower_case`` 915 - InlineNamespacePrefix of ``pre_`` 916 - InlineNamespaceSuffix of ``_post`` 917 918Identifies and/or transforms inline namespaces names as follows: 919 920Before: 921 922.. code-block:: c++ 923 924 namespace FOO_NS { 925 inline namespace InlineNamespace { 926 ... 927 } 928 } // namespace FOO_NS 929 930After: 931 932.. code-block:: c++ 933 934 namespace FOO_NS { 935 inline namespace pre_inlinenamespace_post { 936 ... 937 } 938 } // namespace FOO_NS 939 940.. option:: LocalConstantCase 941 942 When defined, the check will ensure local constant names conform to the 943 selected casing. 944 945.. option:: LocalConstantPrefix 946 947 When defined, the check will ensure local constant names will add the 948 prefixed with the given value (regardless of casing). 949 950.. option:: LocalConstantSuffix 951 952 When defined, the check will ensure local constant names will add the 953 suffix with the given value (regardless of casing). 954 955For example using values of: 956 957 - LocalConstantCase of ``lower_case`` 958 - LocalConstantPrefix of ``pre_`` 959 - LocalConstantSuffix of ``_post`` 960 961Identifies and/or transforms local constant names as follows: 962 963Before: 964 965.. code-block:: c++ 966 967 void foo() { int const local_Constant = 3; } 968 969After: 970 971.. code-block:: c++ 972 973 void foo() { int const pre_local_constant_post = 3; } 974 975.. option:: LocalConstantPointerCase 976 977 When defined, the check will ensure local constant pointer names conform to the 978 selected casing. 979 980.. option:: LocalConstantPointerPrefix 981 982 When defined, the check will ensure local constant pointer names will add the 983 prefixed with the given value (regardless of casing). 984 985.. option:: LocalConstantPointerSuffix 986 987 When defined, the check will ensure local constant pointer names will add the 988 suffix with the given value (regardless of casing). 989 990For example using values of: 991 992 - LocalConstantPointerCase of ``lower_case`` 993 - LocalConstantPointerPrefix of ``pre_`` 994 - LocalConstantPointerSuffix of ``_post`` 995 996Identifies and/or transforms local constant pointer names as follows: 997 998Before: 999 1000.. code-block:: c++ 1001 1002 void foo() { int const *local_Constant = 3; } 1003 1004After: 1005 1006.. code-block:: c++ 1007 1008 void foo() { int const *pre_local_constant_post = 3; } 1009 1010.. option:: LocalPointerCase 1011 1012 When defined, the check will ensure local pointer names conform to the 1013 selected casing. 1014 1015.. option:: LocalPointerPrefix 1016 1017 When defined, the check will ensure local pointer names will add the 1018 prefixed with the given value (regardless of casing). 1019 1020.. option:: LocalPointerSuffix 1021 1022 When defined, the check will ensure local pointer names will add the 1023 suffix with the given value (regardless of casing). 1024 1025For example using values of: 1026 1027 - LocalPointerCase of ``lower_case`` 1028 - LocalPointerPrefix of ``pre_`` 1029 - LocalPointerSuffix of ``_post`` 1030 1031Identifies and/or transforms local pointer names as follows: 1032 1033Before: 1034 1035.. code-block:: c++ 1036 1037 void foo() { int *local_Constant; } 1038 1039After: 1040 1041.. code-block:: c++ 1042 1043 void foo() { int *pre_local_constant_post; } 1044 1045.. option:: LocalVariableCase 1046 1047 When defined, the check will ensure local variable names conform to the 1048 selected casing. 1049 1050.. option:: LocalVariablePrefix 1051 1052 When defined, the check will ensure local variable names will add the 1053 prefixed with the given value (regardless of casing). 1054 1055.. option:: LocalVariableSuffix 1056 1057 When defined, the check will ensure local variable names will add the 1058 suffix with the given value (regardless of casing). 1059 1060For example using values of: 1061 1062 - LocalVariableCase of ``lower_case`` 1063 - LocalVariablePrefix of ``pre_`` 1064 - LocalVariableSuffix of ``_post`` 1065 1066Identifies and/or transforms local variable names as follows: 1067 1068Before: 1069 1070.. code-block:: c++ 1071 1072 void foo() { int local_Constant; } 1073 1074After: 1075 1076.. code-block:: c++ 1077 1078 void foo() { int pre_local_constant_post; } 1079 1080.. option:: MacroDefinitionCase 1081 1082 When defined, the check will ensure macro definitions conform to the 1083 selected casing. 1084 1085.. option:: MacroDefinitionPrefix 1086 1087 When defined, the check will ensure macro definitions will add the 1088 prefixed with the given value (regardless of casing). 1089 1090.. option:: MacroDefinitionSuffix 1091 1092 When defined, the check will ensure macro definitions will add the 1093 suffix with the given value (regardless of casing). 1094 1095For example using values of: 1096 1097 - MacroDefinitionCase of ``lower_case`` 1098 - MacroDefinitionPrefix of ``pre_`` 1099 - MacroDefinitionSuffix of ``_post`` 1100 1101Identifies and/or transforms macro definitions as follows: 1102 1103Before: 1104 1105.. code-block:: c 1106 1107 #define MY_MacroDefinition 1108 1109After: 1110 1111.. code-block:: c 1112 1113 #define pre_my_macro_definition_post 1114 1115Note: This will not warn on builtin macros or macros defined on the command line 1116using the ``-D`` flag. 1117 1118.. option:: MemberCase 1119 1120 When defined, the check will ensure member names conform to the 1121 selected casing. 1122 1123.. option:: MemberPrefix 1124 1125 When defined, the check will ensure member names will add the 1126 prefixed with the given value (regardless of casing). 1127 1128.. option:: MemberSuffix 1129 1130 When defined, the check will ensure member names will add the 1131 suffix with the given value (regardless of casing). 1132 1133For example using values of: 1134 1135 - MemberCase of ``lower_case`` 1136 - MemberPrefix of ``pre_`` 1137 - MemberSuffix of ``_post`` 1138 1139Identifies and/or transforms member names as follows: 1140 1141Before: 1142 1143.. code-block:: c++ 1144 1145 class Foo { 1146 char MY_ConstMember_string[4]; 1147 } 1148 1149After: 1150 1151.. code-block:: c++ 1152 1153 class Foo { 1154 char pre_my_constmember_string_post[4]; 1155 } 1156 1157.. option:: MethodCase 1158 1159 When defined, the check will ensure method names conform to the 1160 selected casing. 1161 1162.. option:: MethodPrefix 1163 1164 When defined, the check will ensure method names will add the 1165 prefixed with the given value (regardless of casing). 1166 1167.. option:: MethodSuffix 1168 1169 When defined, the check will ensure method names will add the 1170 suffix with the given value (regardless of casing). 1171 1172For example using values of: 1173 1174 - MethodCase of ``lower_case`` 1175 - MethodPrefix of ``pre_`` 1176 - MethodSuffix of ``_post`` 1177 1178Identifies and/or transforms method names as follows: 1179 1180Before: 1181 1182.. code-block:: c++ 1183 1184 class Foo { 1185 char MY_Method_string(); 1186 } 1187 1188After: 1189 1190.. code-block:: c++ 1191 1192 class Foo { 1193 char pre_my_method_string_post(); 1194 } 1195 1196.. option:: NamespaceCase 1197 1198 When defined, the check will ensure namespace names conform to the 1199 selected casing. 1200 1201.. option:: NamespacePrefix 1202 1203 When defined, the check will ensure namespace names will add the 1204 prefixed with the given value (regardless of casing). 1205 1206.. option:: NamespaceSuffix 1207 1208 When defined, the check will ensure namespace names will add the 1209 suffix with the given value (regardless of casing). 1210 1211For example using values of: 1212 1213 - NamespaceCase of ``lower_case`` 1214 - NamespacePrefix of ``pre_`` 1215 - NamespaceSuffix of ``_post`` 1216 1217Identifies and/or transforms namespace names as follows: 1218 1219Before: 1220 1221.. code-block:: c++ 1222 1223 namespace FOO_NS { 1224 ... 1225 } 1226 1227After: 1228 1229.. code-block:: c++ 1230 1231 namespace pre_foo_ns_post { 1232 ... 1233 } 1234 1235.. option:: ParameterCase 1236 1237 When defined, the check will ensure parameter names conform to the 1238 selected casing. 1239 1240.. option:: ParameterPrefix 1241 1242 When defined, the check will ensure parameter names will add the 1243 prefixed with the given value (regardless of casing). 1244 1245.. option:: ParameterSuffix 1246 1247 When defined, the check will ensure parameter names will add the 1248 suffix with the given value (regardless of casing). 1249 1250For example using values of: 1251 1252 - ParameterCase of ``lower_case`` 1253 - ParameterPrefix of ``pre_`` 1254 - ParameterSuffix of ``_post`` 1255 1256Identifies and/or transforms parameter names as follows: 1257 1258Before: 1259 1260.. code-block:: c++ 1261 1262 void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter); 1263 1264After: 1265 1266.. code-block:: c++ 1267 1268 void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter); 1269 1270.. option:: ParameterPackCase 1271 1272 When defined, the check will ensure parameter pack names conform to the 1273 selected casing. 1274 1275.. option:: ParameterPackPrefix 1276 1277 When defined, the check will ensure parameter pack names will add the 1278 prefixed with the given value (regardless of casing). 1279 1280.. option:: ParameterPackSuffix 1281 1282 When defined, the check will ensure parameter pack names will add the 1283 suffix with the given value (regardless of casing). 1284 1285For example using values of: 1286 1287 - ParameterPackCase of ``lower_case`` 1288 - ParameterPackPrefix of ``pre_`` 1289 - ParameterPackSuffix of ``_post`` 1290 1291Identifies and/or transforms parameter pack names as follows: 1292 1293Before: 1294 1295.. code-block:: c++ 1296 1297 template <typename... TYPE_parameters> { 1298 void FUNCTION(int... TYPE_parameters); 1299 } 1300 1301After: 1302 1303.. code-block:: c++ 1304 1305 template <typename... TYPE_parameters> { 1306 void FUNCTION(int... pre_type_parameters_post); 1307 } 1308 1309.. option:: PointerParameterCase 1310 1311 When defined, the check will ensure pointer parameter names conform to the 1312 selected casing. 1313 1314.. option:: PointerParameterPrefix 1315 1316 When defined, the check will ensure pointer parameter names will add the 1317 prefixed with the given value (regardless of casing). 1318 1319.. option:: PointerParameterSuffix 1320 1321 When defined, the check will ensure pointer parameter names will add the 1322 suffix with the given value (regardless of casing). 1323 1324For example using values of: 1325 1326 - PointerParameterCase of ``lower_case`` 1327 - PointerParameterPrefix of ``pre_`` 1328 - PointerParameterSuffix of ``_post`` 1329 1330Identifies and/or transforms pointer parameter names as follows: 1331 1332Before: 1333 1334.. code-block:: c++ 1335 1336 void FUNCTION(int *PARAMETER); 1337 1338After: 1339 1340.. code-block:: c++ 1341 1342 void FUNCTION(int *pre_parameter_post); 1343 1344.. option:: PrivateMemberCase 1345 1346 When defined, the check will ensure private member names conform to the 1347 selected casing. 1348 1349.. option:: PrivateMemberPrefix 1350 1351 When defined, the check will ensure private member names will add the 1352 prefixed with the given value (regardless of casing). 1353 1354.. option:: PrivateMemberSuffix 1355 1356 When defined, the check will ensure private member names will add the 1357 suffix with the given value (regardless of casing). 1358 1359For example using values of: 1360 1361 - PrivateMemberCase of ``lower_case`` 1362 - PrivateMemberPrefix of ``pre_`` 1363 - PrivateMemberSuffix of ``_post`` 1364 1365Identifies and/or transforms private member names as follows: 1366 1367Before: 1368 1369.. code-block:: c++ 1370 1371 class Foo { 1372 private: 1373 int Member_Variable; 1374 } 1375 1376After: 1377 1378.. code-block:: c++ 1379 1380 class Foo { 1381 private: 1382 int pre_member_variable_post; 1383 } 1384 1385.. option:: PrivateMethodCase 1386 1387 When defined, the check will ensure private method names conform to the 1388 selected casing. 1389 1390.. option:: PrivateMethodPrefix 1391 1392 When defined, the check will ensure private method names will add the 1393 prefixed with the given value (regardless of casing). 1394 1395.. option:: PrivateMethodSuffix 1396 1397 When defined, the check will ensure private method names will add the 1398 suffix with the given value (regardless of casing). 1399 1400For example using values of: 1401 1402 - PrivateMethodCase of ``lower_case`` 1403 - PrivateMethodPrefix of ``pre_`` 1404 - PrivateMethodSuffix of ``_post`` 1405 1406Identifies and/or transforms private method names as follows: 1407 1408Before: 1409 1410.. code-block:: c++ 1411 1412 class Foo { 1413 private: 1414 int Member_Method(); 1415 } 1416 1417After: 1418 1419.. code-block:: c++ 1420 1421 class Foo { 1422 private: 1423 int pre_member_method_post(); 1424 } 1425 1426.. option:: ProtectedMemberCase 1427 1428 When defined, the check will ensure protected member names conform to the 1429 selected casing. 1430 1431.. option:: ProtectedMemberPrefix 1432 1433 When defined, the check will ensure protected member names will add the 1434 prefixed with the given value (regardless of casing). 1435 1436.. option:: ProtectedMemberSuffix 1437 1438 When defined, the check will ensure protected member names will add the 1439 suffix with the given value (regardless of casing). 1440 1441For example using values of: 1442 1443 - ProtectedMemberCase of ``lower_case`` 1444 - ProtectedMemberPrefix of ``pre_`` 1445 - ProtectedMemberSuffix of ``_post`` 1446 1447Identifies and/or transforms protected member names as follows: 1448 1449Before: 1450 1451.. code-block:: c++ 1452 1453 class Foo { 1454 protected: 1455 int Member_Variable; 1456 } 1457 1458After: 1459 1460.. code-block:: c++ 1461 1462 class Foo { 1463 protected: 1464 int pre_member_variable_post; 1465 } 1466 1467.. option:: ProtectedMethodCase 1468 1469 When defined, the check will ensure protect method names conform to the 1470 selected casing. 1471 1472.. option:: ProtectedMethodPrefix 1473 1474 When defined, the check will ensure protect method names will add the 1475 prefixed with the given value (regardless of casing). 1476 1477.. option:: ProtectedMethodSuffix 1478 1479 When defined, the check will ensure protect method names will add the 1480 suffix with the given value (regardless of casing). 1481 1482For example using values of: 1483 1484 - ProtectedMethodCase of ``lower_case`` 1485 - ProtectedMethodPrefix of ``pre_`` 1486 - ProtectedMethodSuffix of ``_post`` 1487 1488Identifies and/or transforms protect method names as follows: 1489 1490Before: 1491 1492.. code-block:: c++ 1493 1494 class Foo { 1495 protected: 1496 int Member_Method(); 1497 } 1498 1499After: 1500 1501.. code-block:: c++ 1502 1503 class Foo { 1504 protected: 1505 int pre_member_method_post(); 1506 } 1507 1508.. option:: PublicMemberCase 1509 1510 When defined, the check will ensure public member names conform to the 1511 selected casing. 1512 1513.. option:: PublicMemberPrefix 1514 1515 When defined, the check will ensure public member names will add the 1516 prefixed with the given value (regardless of casing). 1517 1518.. option:: PublicMemberSuffix 1519 1520 When defined, the check will ensure public member names will add the 1521 suffix with the given value (regardless of casing). 1522 1523For example using values of: 1524 1525 - PublicMemberCase of ``lower_case`` 1526 - PublicMemberPrefix of ``pre_`` 1527 - PublicMemberSuffix of ``_post`` 1528 1529Identifies and/or transforms public member names as follows: 1530 1531Before: 1532 1533.. code-block:: c++ 1534 1535 class Foo { 1536 public: 1537 int Member_Variable; 1538 } 1539 1540After: 1541 1542.. code-block:: c++ 1543 1544 class Foo { 1545 public: 1546 int pre_member_variable_post; 1547 } 1548 1549.. option:: PublicMethodCase 1550 1551 When defined, the check will ensure public method names conform to the 1552 selected casing. 1553 1554.. option:: PublicMethodPrefix 1555 1556 When defined, the check will ensure public method names will add the 1557 prefixed with the given value (regardless of casing). 1558 1559.. option:: PublicMethodSuffix 1560 1561 When defined, the check will ensure public method names will add the 1562 suffix with the given value (regardless of casing). 1563 1564For example using values of: 1565 1566 - PublicMethodCase of ``lower_case`` 1567 - PublicMethodPrefix of ``pre_`` 1568 - PublicMethodSuffix of ``_post`` 1569 1570Identifies and/or transforms public method names as follows: 1571 1572Before: 1573 1574.. code-block:: c++ 1575 1576 class Foo { 1577 public: 1578 int Member_Method(); 1579 } 1580 1581After: 1582 1583.. code-block:: c++ 1584 1585 class Foo { 1586 public: 1587 int pre_member_method_post(); 1588 } 1589 1590.. option:: StaticConstantCase 1591 1592 When defined, the check will ensure static constant names conform to the 1593 selected casing. 1594 1595.. option:: StaticConstantPrefix 1596 1597 When defined, the check will ensure static constant names will add the 1598 prefixed with the given value (regardless of casing). 1599 1600.. option:: StaticConstantSuffix 1601 1602 When defined, the check will ensure static constant names will add the 1603 suffix with the given value (regardless of casing). 1604 1605For example using values of: 1606 1607 - StaticConstantCase of ``lower_case`` 1608 - StaticConstantPrefix of ``pre_`` 1609 - StaticConstantSuffix of ``_post`` 1610 1611Identifies and/or transforms static constant names as follows: 1612 1613Before: 1614 1615.. code-block:: c++ 1616 1617 static unsigned const MyConstStatic_array[] = {1, 2, 3}; 1618 1619After: 1620 1621.. code-block:: c++ 1622 1623 static unsigned const pre_myconststatic_array_post[] = {1, 2, 3}; 1624 1625.. option:: StaticVariableCase 1626 1627 When defined, the check will ensure static variable names conform to the 1628 selected casing. 1629 1630.. option:: StaticVariablePrefix 1631 1632 When defined, the check will ensure static variable names will add the 1633 prefixed with the given value (regardless of casing). 1634 1635.. option:: StaticVariableSuffix 1636 1637 When defined, the check will ensure static variable names will add the 1638 suffix with the given value (regardless of casing). 1639 1640For example using values of: 1641 1642 - StaticVariableCase of ``lower_case`` 1643 - StaticVariablePrefix of ``pre_`` 1644 - StaticVariableSuffix of ``_post`` 1645 1646Identifies and/or transforms static variable names as follows: 1647 1648Before: 1649 1650.. code-block:: c++ 1651 1652 static unsigned MyStatic_array[] = {1, 2, 3}; 1653 1654After: 1655 1656.. code-block:: c++ 1657 1658 static unsigned pre_mystatic_array_post[] = {1, 2, 3}; 1659 1660.. option:: StructCase 1661 1662 When defined, the check will ensure struct names conform to the 1663 selected casing. 1664 1665.. option:: StructPrefix 1666 1667 When defined, the check will ensure struct names will add the 1668 prefixed with the given value (regardless of casing). 1669 1670.. option:: StructSuffix 1671 1672 When defined, the check will ensure struct names will add the 1673 suffix with the given value (regardless of casing). 1674 1675For example using values of: 1676 1677 - StructCase of ``lower_case`` 1678 - StructPrefix of ``pre_`` 1679 - StructSuffix of ``_post`` 1680 1681Identifies and/or transforms struct names as follows: 1682 1683Before: 1684 1685.. code-block:: c++ 1686 1687 struct FOO { 1688 FOO(); 1689 ~FOO(); 1690 }; 1691 1692After: 1693 1694.. code-block:: c++ 1695 1696 struct pre_foo_post { 1697 pre_foo_post(); 1698 ~pre_foo_post(); 1699 }; 1700 1701.. option:: TemplateParameterCase 1702 1703 When defined, the check will ensure template parameter names conform to the 1704 selected casing. 1705 1706.. option:: TemplateParameterPrefix 1707 1708 When defined, the check will ensure template parameter names will add the 1709 prefixed with the given value (regardless of casing). 1710 1711.. option:: TemplateParameterSuffix 1712 1713 When defined, the check will ensure template parameter names will add the 1714 suffix with the given value (regardless of casing). 1715 1716For example using values of: 1717 1718 - TemplateParameterCase of ``lower_case`` 1719 - TemplateParameterPrefix of ``pre_`` 1720 - TemplateParameterSuffix of ``_post`` 1721 1722Identifies and/or transforms template parameter names as follows: 1723 1724Before: 1725 1726.. code-block:: c++ 1727 1728 template <typename T> class Foo {}; 1729 1730After: 1731 1732.. code-block:: c++ 1733 1734 template <typename pre_t_post> class Foo {}; 1735 1736.. option:: TemplateTemplateParameterCase 1737 1738 When defined, the check will ensure template template parameter names conform to the 1739 selected casing. 1740 1741.. option:: TemplateTemplateParameterPrefix 1742 1743 When defined, the check will ensure template template parameter names will add the 1744 prefixed with the given value (regardless of casing). 1745 1746.. option:: TemplateTemplateParameterSuffix 1747 1748 When defined, the check will ensure template template parameter names will add the 1749 suffix with the given value (regardless of casing). 1750 1751For example using values of: 1752 1753 - TemplateTemplateParameterCase of ``lower_case`` 1754 - TemplateTemplateParameterPrefix of ``pre_`` 1755 - TemplateTemplateParameterSuffix of ``_post`` 1756 1757Identifies and/or transforms template template parameter names as follows: 1758 1759Before: 1760 1761.. code-block:: c++ 1762 1763 template <template <typename> class TPL_parameter, int COUNT_params, 1764 typename... TYPE_parameters> 1765 1766After: 1767 1768.. code-block:: c++ 1769 1770 template <template <typename> class pre_tpl_parameter_post, int COUNT_params, 1771 typename... TYPE_parameters> 1772 1773.. option:: TypeAliasCase 1774 1775 When defined, the check will ensure type alias names conform to the 1776 selected casing. 1777 1778.. option:: TypeAliasPrefix 1779 1780 When defined, the check will ensure type alias names will add the 1781 prefixed with the given value (regardless of casing). 1782 1783.. option:: TypeAliasSuffix 1784 1785 When defined, the check will ensure type alias names will add the 1786 suffix with the given value (regardless of casing). 1787 1788For example using values of: 1789 1790 - TypeAliasCase of ``lower_case`` 1791 - TypeAliasPrefix of ``pre_`` 1792 - TypeAliasSuffix of ``_post`` 1793 1794Identifies and/or transforms type alias names as follows: 1795 1796Before: 1797 1798.. code-block:: c++ 1799 1800 using MY_STRUCT_TYPE = my_structure; 1801 1802After: 1803 1804.. code-block:: c++ 1805 1806 using pre_my_struct_type_post = my_structure; 1807 1808.. option:: TypedefCase 1809 1810 When defined, the check will ensure typedef names conform to the 1811 selected casing. 1812 1813.. option:: TypedefPrefix 1814 1815 When defined, the check will ensure typedef names will add the 1816 prefixed with the given value (regardless of casing). 1817 1818.. option:: TypedefSuffix 1819 1820 When defined, the check will ensure typedef names will add the 1821 suffix with the given value (regardless of casing). 1822 1823For example using values of: 1824 1825 - TypedefCase of ``lower_case`` 1826 - TypedefPrefix of ``pre_`` 1827 - TypedefSuffix of ``_post`` 1828 1829Identifies and/or transforms typedef names as follows: 1830 1831Before: 1832 1833.. code-block:: c++ 1834 1835 typedef int MYINT; 1836 1837After: 1838 1839.. code-block:: c++ 1840 1841 typedef int pre_myint_post; 1842 1843.. option:: TypeTemplateParameterCase 1844 1845 When defined, the check will ensure type template parameter names conform to the 1846 selected casing. 1847 1848.. option:: TypeTemplateParameterPrefix 1849 1850 When defined, the check will ensure type template parameter names will add the 1851 prefixed with the given value (regardless of casing). 1852 1853.. option:: TypeTemplateParameterSuffix 1854 1855 When defined, the check will ensure type template parameter names will add the 1856 suffix with the given value (regardless of casing). 1857 1858For example using values of: 1859 1860 - TypeTemplateParameterCase of ``lower_case`` 1861 - TypeTemplateParameterPrefix of ``pre_`` 1862 - TypeTemplateParameterSuffix of ``_post`` 1863 1864Identifies and/or transforms type template parameter names as follows: 1865 1866Before: 1867 1868.. code-block:: c++ 1869 1870 template <template <typename> class TPL_parameter, int COUNT_params, 1871 typename... TYPE_parameters> 1872 1873After: 1874 1875.. code-block:: c++ 1876 1877 template <template <typename> class TPL_parameter, int COUNT_params, 1878 typename... pre_type_parameters_post> 1879 1880.. option:: UnionCase 1881 1882 When defined, the check will ensure union names conform to the 1883 selected casing. 1884 1885.. option:: UnionPrefix 1886 1887 When defined, the check will ensure union names will add the 1888 prefixed with the given value (regardless of casing). 1889 1890.. option:: UnionSuffix 1891 1892 When defined, the check will ensure union names will add the 1893 suffix with the given value (regardless of casing). 1894 1895For example using values of: 1896 1897 - UnionCase of ``lower_case`` 1898 - UnionPrefix of ``pre_`` 1899 - UnionSuffix of ``_post`` 1900 1901Identifies and/or transforms union names as follows: 1902 1903Before: 1904 1905.. code-block:: c++ 1906 1907 union FOO { 1908 int a; 1909 char b; 1910 }; 1911 1912After: 1913 1914.. code-block:: c++ 1915 1916 union pre_foo_post { 1917 int a; 1918 char b; 1919 }; 1920 1921.. option:: ValueTemplateParameterCase 1922 1923 When defined, the check will ensure value template parameter names conform to the 1924 selected casing. 1925 1926.. option:: ValueTemplateParameterPrefix 1927 1928 When defined, the check will ensure value template parameter names will add the 1929 prefixed with the given value (regardless of casing). 1930 1931.. option:: ValueTemplateParameterSuffix 1932 1933 When defined, the check will ensure value template parameter names will add the 1934 suffix with the given value (regardless of casing). 1935 1936For example using values of: 1937 1938 - ValueTemplateParameterCase of ``lower_case`` 1939 - ValueTemplateParameterPrefix of ``pre_`` 1940 - ValueTemplateParameterSuffix of ``_post`` 1941 1942Identifies and/or transforms value template parameter names as follows: 1943 1944Before: 1945 1946.. code-block:: c++ 1947 1948 template <template <typename> class TPL_parameter, int COUNT_params, 1949 typename... TYPE_parameters> 1950 1951After: 1952 1953.. code-block:: c++ 1954 1955 template <template <typename> class TPL_parameter, int pre_count_params_post, 1956 typename... TYPE_parameters> 1957 1958.. option:: VariableCase 1959 1960 When defined, the check will ensure variable names conform to the 1961 selected casing. 1962 1963.. option:: VariablePrefix 1964 1965 When defined, the check will ensure variable names will add the 1966 prefixed with the given value (regardless of casing). 1967 1968.. option:: VariableSuffix 1969 1970 When defined, the check will ensure variable names will add the 1971 suffix with the given value (regardless of casing). 1972 1973For example using values of: 1974 1975 - VariableCase of ``lower_case`` 1976 - VariablePrefix of ``pre_`` 1977 - VariableSuffix of ``_post`` 1978 1979Identifies and/or transforms variable names as follows: 1980 1981Before: 1982 1983.. code-block:: c++ 1984 1985 unsigned MyVariable; 1986 1987After: 1988 1989.. code-block:: c++ 1990 1991 unsigned pre_myvariable_post; 1992 1993.. option:: VirtualMethodCase 1994 1995 When defined, the check will ensure virtual method names conform to the 1996 selected casing. 1997 1998.. option:: VirtualMethodPrefix 1999 2000 When defined, the check will ensure virtual method names will add the 2001 prefixed with the given value (regardless of casing). 2002 2003.. option:: VirtualMethodSuffix 2004 2005 When defined, the check will ensure virtual method names will add the 2006 suffix with the given value (regardless of casing). 2007 2008For example using values of: 2009 2010 - VirtualMethodCase of ``lower_case`` 2011 - VirtualMethodPrefix of ``pre_`` 2012 - VirtualMethodSuffix of ``_post`` 2013 2014Identifies and/or transforms virtual method names as follows: 2015 2016Before: 2017 2018.. code-block:: c++ 2019 2020 class Foo { 2021 public: 2022 virtual int MemberFunction(); 2023 } 2024 2025After: 2026 2027.. code-block:: c++ 2028 2029 class Foo { 2030 public: 2031 virtual int pre_member_function_post(); 2032 } 2033