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 . |