Package rules.ATLAS

Class Summary
ATLASRuleChecker Class ATLASRuleChecker realizes the check of the registered coding rules.
CA10Rule Class CA10Rule implements the rule CA10 (Do not use asm (the assembler macro facility of C++)) It extends the abstract class Rule and implements the abstract method check(Module module).
CA11Rule Class CA11Rule implements the rule CA11 (Do not use the keyword struct) It extends the abstract class Rule and implements the abstract method check(Module module).
CA12Rule Class CA12Rule implements the rule CA12 (Do not use file scope objects; use class scope instead) It extends the abstract class Rule and implements the abstract method check(Module module).
CA13Rule Class CA13Rule implements the rule CA13 (Use the bool type of C++ for booleans) It extends the abstract class Rule and implements the abstract method check(Module module).
CA14Rule Class CA14Rule implements the rule CA14 (Avoid pointer arithmetic) It extends the abstract class Rule and implements the abstract method check(Module module).
CA1Rule Class CA1Rule implements the rule CA1 (Use new and delete instead of malloc, calloc, realloc and free) It extends the abstract class Rule and implements the abstract method check(Module module).
CA2Rule Class CA2Rule implements the rule CA2 (Use the iostream functions rather than those defined in stdio) It extends the abstract class Rule and implements the abstract method check(Module module).
CA3Rule Class CA3Rule implements the rule CA3 (Do not use the ellipsis notation for function arguments) It extends the abstract class Rule and implements the abstract method check(Module module).
CA4Rule Class CA4Rule implements the rule CA4 (Do not use preprocessor macros, except for system provided macros) It extends the abstract class Rule and implements the abstract method check(Module module).
CA5Rule Class CA5Rule implements the rule CA5 (The only permissible use of #ifdef is to precede a block of non-portable code and to allow the template declaration as CT1) It extends the abstract class Rule and implements the abstract method check(Module module).
CA7Rule Class CA7Rule implements the rule CA7 (Use the integer constant 0 for the null pointer; don't use NULL) It extends the abstract class Rule and implements the abstract method check(Module module).
CA9Rule Class CA9Rule implements the rule CA9 (Do not use union types) It extends the abstract class Rule and implements the abstract method check(Module module).
CB1Rule Class CB1Rule implements the rule CB1 (Do not declare data members to be public) It extends the abstract class Rule and implements the abstract method check(Module module).
CB2Rule Class CB2Rule implements the rule CB2 (If a class has at least one virtual method then it must have a public virtual destructor, or (exceptionally) a protected destructor) It extends the abstract class Rule and implements the abstract method check(Module module).
CB3Rule Class CB3Rule implements the rule CB3 (Always re-declare virtual functions as virtual in derived classes.) It extends the abstract class Rule and implements the abstract method check(Module module).
CB4Rule Class CB4Rule implements the rule CB4 (Avoid multiple inheritance, except for abstract interfaces.) It extends the abstract class Rule and implements the abstract method check(Module module).
CB5Rule Class CB5Rule implements the rule CB5 (Avoid the use of friend declarations) It extends the abstract class Rule and implements the abstract method check(Module module).
CC2Rule Class CC2Rule implements the rule CC2 (Use the new cast operators (dynamic_cast and static_cast) instead of the C-Style casts) It extends the abstract class Rule and implements the abstract method check(Module module).
CC3Rule Class CC3Rule implements the rule CC3 (Do not convert const objects to non-const) It extends the abstract class Rule and implements the abstract method check(Module module).
CC4Rule Class CC4Rule implements the rule CC4 (Do not use \"reinterpret_cast\") It extends the abstract class Rule and implements the abstract method check(Module module).
CF1Rule Class CF1Rule implements the rule CF1 (Do not change a loop variable inside a for loop block) It extends the abstract class Rule and implements the abstract method check(Module module).
CF2Rule Class CF2Rule implements the rule CF2 (All switch statements must have a default clause) It extends the abstract class Rule and implements the abstract method check(Module module).
CF3Rule Class CF3Rule implements the rule CF3 (Each clause of a switch statement must end with "break".) It extends the abstract class Rule and implements the abstract method check(Module module).
CF4Rule Class CF4Rule implements the rule CF4 (All "if statements" which do not fit in one line must have brackets around the conditional statement) It extends the abstract class Rule and implements the abstract method check(Module module).
CF5Rule Class CF5Rule implements the rule CF5 (Do not use goto) It extends the abstract class Rule and implements the abstract method check(Module module).
CH5Rule Class CH5Rule implements the rule CH5 (Use exception specification to declare which exceptions might be thrown from a function.) It extends the abstract class Rule and implements the abstract method check(Module module).
CI1Rule Class CI1Rule implements the rule CI1 (Header files must contain no implementation except for small functions to be inlined.
CI2Rule Class CI2Rule implements the rule CI2 (Functions which have a return value must not modify their arguments nor have any side effects) It extends the abstract class Rule and implements the abstract method check(Module module).
CI3Rule Class CI3Rule implements the rule CI3 ((1) Pass by value arguments which are not to be modified and are built-in-types or small objects, (2) otherwise pass arguments of class types by reference or, if necessary, by pointer) It extends the abstract class Rule and implements the abstract method check(Module module).
CI4Rule Class CI4Rule implements the rule CI4 (Have operator= return *this) It extends the abstract class Rule and implements the abstract method check(Module module).
CI5Rule Class CI5Rule implements the rule CI5 (Declare a pointer or reference argument, passed to a function, as const if the function does not change the object bound to it.) It extends the abstract class Rule and implements the abstract method check(Module module).
CI6Rule Class CI6Rule implements the rule CI6 (The argument to a copy constructor and to an assignment operator must be a const reference) It extends the abstract class Rule and implements the abstract method check(Module module).
CI7Rule Class CI7Rule implements the rule CI7 (In a class method do not return pointer or non-const references to private data members) It extends the abstract class Rule and implements the abstract method check(Module module).
CI8Rule Class CI8Rule implements the rule CI8 (Declare as const a member function that does not affect the state of the object) It extends the abstract class Rule and implements the abstract method check(Module module).
CI9Rule Class CI9Rule implements the rule CI9 (Do not let const member functions change the state of the program) It extends the abstract class Rule and implements the abstract method check(Module module).
CL10Rule Class CL10Rule implements the rule CL10 (Assignment member functions must work correctly when the left and right operands are the same object) It extends the abstract class Rule and implements the abstract method check(Module module).
CL11Rule Class CL11Rule implements the rule CL11 (Virtual base classes (i.e.
CL1Rule Class CL1Rule implements the rule CL1 (Declare each variable with the smallest possible scope and initialize at the same time) It extends the abstract class Rule and implements the abstract method check(Module module).
CL2Rule Class CL2Rule implements the rule CL2 (Do not use literals in expressions) It extends the abstract class Rule and implements the abstract method check(Module module).
CL3Rule Class CL3Rule implements the rule CL3 (Declare each type of variables in a separate declaration statement, and do not declare different types (e.g.
CL4Rule Class CL4Rule implements the rule CL4 (Do not use the same variable name in outer and inner scope) It extends the abstract class Rule and implements the abstract method check(Module module).
CL5Rule Class CL5Rule implements the rule CL5 (Let the order in the initializer list be the same as the order of the declarations in the header file: first base classes, then data members.) It extends the abstract class Rule and implements the abstract method check(Module module).
CL6Rule Class CL6Rule implements the rule CL6 (A function must never return, or in any other way give access to, references or pointers to local variables outside the scope in which they are declared) It extends the abstract class Rule and implements the abstract method check(Module module).
CL8Rule Class CL8Rule implements the rule CL8 (A copy constructor is mandatory, together with an assignment operator, if a class has a built-in pointer member data) It extends the abstract class Rule and implements the abstract method check(Module module).
CN2Rule Class CN2Rule implements the rule CN2 (A function must not use the delete operator on any pointer passed to it as an argument) It extends the abstract class Rule and implements the abstract method check(Module module).
CN3Rule Class CN3Rule implements the rule CN3 (Do not access or reference to a deleted object) It extends the abstract class Rule and implements the abstract method check(Module module).
CN4Rule Class CN4Rule implements the rule CN4 (After deleting a pointer assign it to zero) It extends the abstract class Rule and implements the abstract method check(Module module).
CO1Rule Class CO1Rule implements the rule CO1 (Header file must begin and end with multiple-inclusion protection.) It extends the abstract class Rule and implements the abstract method check(Module module).
CO2Rule Class CO2Rule implements the rule CO2 (Use forward declaration instead of including a header file, if this is sufficient) It extends the abstract class Rule and implements the abstract method check(Module module).
CO3Rule Class CO3Rule implements the rule CO3 (Each header file must contain one class (or embedded or very tightly coupled classes) declaration only It extends the abstract class Rule and implements the abstract method check(Module module).
CO4Rule Class CO4Rule implements the rule CO4 (Implementation files must hold the member function definitions for a single class (or embedded or very tightly coupled classes) as defined in the corresponding header file) It extends the abstract class Rule and implements the abstract method check(Module module).
CP10Rule Class CP10Rule implements the rule CP10 (Use long (not int) and double (not float)) It extends the abstract class Rule and implements the abstract method check(Module module).
CP4Rule Class CP4Rule implements the rule CP4 (Do not specify absolute directory names in include directives.
CP7Rule Class CP7Rule implements the rule CP7 (Take machine precision into account in your conditional statements.
CP8Rule Class CP8Rule implements the rule CP8 (Do not depend on the order of evaluation of arguments to a function, in particular never use ++ and -- operators on method arguments in function calls) It extends the abstract class Rule and implements the abstract method check(Module module).
CR1Rule Class CR1Rule implements the rule CR1 (Avoid duplicated code) It extends the abstract class Rule and implements the abstract method check(Module module).
CR3Rule Class CR3Rule implements the rule CR3 (Typedefs are discouraged) It extends the abstract class Rule and implements the abstract method check(Module module).
CS1Rule Class CS1Rule implements the rule CS1 (Do not declare global variables) It extends the abstract class Rule and implements the abstract method check(Module module).
CS2Rule Class CS2Rule implements the rule CS2 (Use global functions only for symmetric binary operators) It extends the abstract class Rule and implements the abstract method check(Module module).
CT1Rule Class CT1Rule implements the rule CT1 (Declare a template in a .h file, as for any other class, but conditionally include the definition at the end.) It extends the abstract class Rule and implements the abstract method check(Module module).
NC1Rule Class NC1Rule implements the rule NC1 (Use prefix "m_" for private attributes (i.e.
NC2Rule Class NC2Rule implements the rule NC2 (Use prefix "s_" for private static attributes (i.e.
NC5Rule Class NC5Rule implements the rule NC5 (Start class names, typedefs and enum types with an uppercase letter) It extends the abstract class Rule and implements the abstract method check(Module module).
NC6Rule Class NC6Rule implements the rule NC6 (Start names of variables and functions with a lowercase letter) It extends the abstract class Rule and implements the abstract method check(Module module).
NC7Rule Class NC7Rule implements the rule NC7 (In names that consist of more than one word, write the words together, and start each word that follows the first with an upper case letter) It extends the abstract class Rule and implements the abstract method check(Module module).
NF1Rule Class NF1Rule implements the rule NF1 (The name of the header file must be the same of the class it defines, with a suffix ".h" appended.) It extends the abstract class Rule and implements the abstract method check(Module module).
NF2Rule Class NF2Rule implements the rule NF2 (The name of the implementation file must be the same of the class it implements, with a suffix ".cxx" appended.) It extends the abstract class Rule and implements the abstract method check(Module module)
NI1Rule Class NI1Rule implements the rule NI1 (Do not create very similar names) It extends the abstract class Rule and implements the abstract method check(Module module).
NI2Rule Class NI2Rule implements the rule NI2 (Do not use identifiers that begin with an underscore) It extends the abstract class Rule and implements the abstract method check(Module module).
SC1Rule Class SC1Rule implements the rule SC1 (Use \"//\" for comments) It extends the abstract class Rule and implements the abstract method check(Module module).
SG1Rule Class SG1Rule implements the rule SG1 (The public, protected and private sections of a class must be declared in that order.
SG2Rule Class SG2Rule implements the rule SG2 (Keep the ordering of methods in the header file and in the source file identical.) It extends the abstract class Rule and implements the abstract method check(Module module).
SG3Rule Class SG3Rule implements the rule SG3 (Statements should not exceed 100 characters (excluding leading spaces).
SG4Rule Class SG4Rule implements the rule SG4 (Limit line length to 120 character positions (including white space and expanded tabs)) It extends the abstract class Rule and implements the abstract method check(Module module).
SG5Rule Class SG5Rule implements the rule SG5 (Include meaningful dummy argument names in function declarations.
SG7Rule Class SG7Rule implements the rule SG7 (Do not use spaces in front of [], (), and to either side of .