gstlearn  1.0.0
CCC
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | List of all members
Style Class Reference

The Style class contains all the recommended styles considerations. It has no special functionalities.
This is only a template class that developers can mimic. More...

#include <Style.hpp>

Public Member Functions

 Style ()
 
 Style (const Style &r)
 
Style & operator= (const Style &r)
 
virtual ~Style ()
 
int DocumentedStandard (int myArg) const
 
int DocumentedWithFormula (int myArg) const
 
int UnusedArgument (int a)
 
double getArgDouble () const
 
int getArgInt () const
 
const VectorDouble & getArgVectorDouble () const
 
const VectorInt & getArgVectorInt () const
 
void setArgDouble (double argDouble)
 
void setArgInt (int argInt)
 
void setArgVectorDouble (const VectorDouble &argVectorDouble)
 
void setArgVectorInt (const VectorInt &argVectorInt)
 

Static Public Member Functions

static void myFunction (int myArgInt, double myArgDoubleDef=2.)
 

Private Member Functions

int _increment (int arg) const
 

Private Attributes

int _argInt
 Private attribute of type int More...
 
double _argDouble
 Private attribute of type double More...
 
VectorInt _argVectorInt
 Private attribute of type VectorInt More...
 
VectorDouble _argVectorDouble
 Private attribute of type VectorDouble More...
 

Detailed Description

The Style class contains all the recommended styles considerations. It has no special functionalities.
This is only a template class that developers can mimic.

This class includes coding rules and doxygen documentation examples.

Since doxygen 1.8.0, Markdown support is available in doxygen comments (see here).
Look at gstlearn READMEs for a quick overview of Markdown syntax.

Main class features

This class demonstrates:

  • How to use doxygen for documenting the class:
    • this global class description
    • the private member attributes documentation
    • all methods and arguments documentation (at least public ones)
  • Some mandatory coding rules (see below):
    • constructors
    • pro active usage of const
    • error handling with exceptions,
    • etc...
  • How to use some gstlearn global features such has:
    • Enumerations (see AEnum) - TODO
    • DECLARE_UNUSED macro (need including geoslib_define.h)
    • ...to be expanded
  • Some coding constraints due to the [customized] SWIG for R version:
    • limit the use of function overriding
    • do not use namespace or static variables in default argument values
    • do not comment the argument name when it is unused (use DECLARE_UNUSED)
    • do not use following argument names: 'in', '_*'
    • always inherit from pure virtual classes in last position (ex: ICloneable)

C++ naming convention

Here are some rules about naming C++ types, functions, variables and symbols:

  • Only usual abbreviations are accepted (ie: min, max, idx, temp, ...)
  • Constants (macro): all in capitals with underscore (MAX_LENGTH)
  • Enums: idem
  • Class or structure names: upper camel case (ie: SparseMatrix, Database)
  • Aliases (typedef): idem
  • Class' methods: lower camel case (ie: loadData, getArmonicMean, isEmpty)
  • Class' attributes (variables): idem
  • Anything which is private or protected in a class starts with underscore (ie: _myMember)
  • Local variables: lower case separated by underscore (ie: temp_value, color_idx)

C++ coding rules

Here are some coding rules (good practices) for C++ developers:

  • Do not use goto
  • Use break only in switch cases
  • Limit the number of global variables
  • Use const every where
  • Do not use old C-style (use C++ STL)
  • Do not use using namespace
  • Make the includes list as small as possible in C++ header (use forward declaration)
  • Expose only what is necessary (all is private by default)

More good practices available here

Class' constructors/destructors

Here are some rules regarding constructors and destructors:

  • Always add a default constructor (no arguments or arguments with default values)
  • Always add a copy constructor (with some exceptions - see Calc* classes)
  • Always add an assignment operator (with some exceptions - see Calc* classes)
  • Always add a virtual destructor

Documenting Methods

Main principles for documenting class methods are the following:

  • Add one-line comment before each public prototype in the C++ header
  • Add a doxygen section above each method definition in the C++ body
  • All this except for trivial methods*, constructors and destructors
  • Define pointer for ENUM. Example to point to EMorpho Enum: EMorpho

Constructor & Destructor Documentation

◆ Style() [1/2]

Style::Style ( )

Default constructor

Always use the initialization list to set the default value of each class member. Put attributes in the same order than their declaration in the C++ header.

◆ Style() [2/2]

Style::Style ( const Style &  r)

Copy constructor

Always use the initialization list to set the value of each class member. Put attributes in the same order than their declaration in the C++ header.

◆ ~Style()

Style::~Style ( )
virtual

Destructor

Always free pointers and clear the lists of the class

Member Function Documentation

◆ _increment()

int Style::_increment ( int  arg) const
private

Example of a private method

Parameters
[in]argInput integer argument
Returns
The input argument incremented

◆ DocumentedStandard()

int Style::DocumentedStandard ( int  myArg) const

A method with standard argument documentation

Parameters
[in]myArgHere should be placed the description of this argument
Returns
Description of the returned value

◆ DocumentedWithFormula()

int Style::DocumentedWithFormula ( int  myArg) const

Documentation with Latex formula

The distance between $ p1=(x_1,y_1) $ and $ p2=(x_2,y_2) $ is $\sqrt{(x_2-x_1)^2+(y_2-y_1)^2}$ (this formula may need to do this: https://github.com/doxygen/doxygen/issues/7484#issuecomment-572503569)

See also
SpaceRN::getDistance
Parameters
[in]myArgHere should be placed the description of this argument
Returns
The value of the argument + 1

◆ myFunction()

void Style::myFunction ( int  myArgInt,
double  myArgDoubleDef = 2. 
)
static

Description of a static function

Parameters
[in]myArgIntInteger argument
[in]myArgDoubleDefDouble argument

◆ operator=()

Style & Style::operator= ( const Style &  r)

Assignment operator

Always protect from self copy if the if statement

◆ UnusedArgument()

int Style::UnusedArgument ( int  a)

A function where the argument is not used (could be the case in abstract methods)

Parameters
[in]aInput argument not used (but documented)
Returns
Error returned code

Member Data Documentation

◆ _argDouble

double Style::_argDouble
private

Private attribute of type double

◆ _argInt

int Style::_argInt
private

Private attribute of type int

◆ _argVectorDouble

VectorDouble Style::_argVectorDouble
private

Private attribute of type VectorDouble

◆ _argVectorInt

VectorInt Style::_argVectorInt
private

Private attribute of type VectorInt

The documentation for this class was generated from the following files: