[clang-format] Comply to Google style.

Author: olivier-stasse

.clang-format

@@ -0,0 +1,3 @@
+---
+ColumnLimit:     80
+...

doc/additionalDoc/debug-doc.h

@@ -1,15 +1,18 @@
 /**
 \page debug Debugging
 
-They are several ways to perform debugging in dynamic-graph depending on your needs or situation:
-- Programmatically inside the entity in C++ will write inside a buffer in a different thread and output in a stream
-(either std::cout or a file). It is detailed in \subpage subp_debug_rt_logger.
-- Programmatically inside the entity in C++ using a member of the entities and the previous real-time mechanism.
-It provides 4 levels of messags :(DEBUG,INFO, WARNING, ERROR). It is described in details here:
-\subpage subp_logger
-- Programmatically in C++ to avoid overhead with macros and handling level as an int: \subpage subp_dbg_trace
-- If you just need to collect informations from signals (like rosbag). You can use
-an entity called Tracer inside the graph:\subpage tracerdoc . <br>
-A real time version exists
-to write directly inside a memory buffer \subpage tracerrealtimedoc
+They are several ways to perform debugging in dynamic-graph depending on your
+needs or situation:
+- Programmatically inside the entity in C++ will write inside a buffer in a
+different thread and output in a stream (either std::cout or a file). It is
+detailed in \subpage subp_debug_rt_logger.
+- Programmatically inside the entity in C++ using a member of the entities and
+the previous real-time mechanism. It provides 4 levels of messags :(DEBUG,INFO,
+WARNING, ERROR). It is described in details here: \subpage subp_logger
+- Programmatically in C++ to avoid overhead with macros and handling level as an
+int: \subpage subp_dbg_trace
+- If you just need to collect informations from signals (like rosbag). You can
+use an entity called Tracer inside the graph:\subpage tracerdoc . <br> A real
+time version exists to write directly inside a memory buffer \subpage
+tracerrealtimedoc
 **/

doc/additionalDoc/debug-logger.h

@@ -8,8 +8,8 @@
 In order to activate the logger you need to add the following lines:
 \code
 #define ENABLE_RT_LOG
-#include <dynamic-graph/real-time-logger.h>
 #include <dynamic-graph/logger.h>
+#include <dynamic-graph/real-time-logger.h>
 \endcode
 
 \subsection subsec_logger_ Initialize the output stream
@@ -39,34 +39,40 @@ The second line specifies at which frequency the STREAM messages should be
 printed.<br>
 The third line specifies the level of message to accept.<br>
 The fourth line returns the level of verbosity.
-In this case, all messages are accepted and the STREAM message are displayed on the output streams once on five. <br>
+In this case, all messages are accepted and the STREAM message are displayed on
+the output streams once on five. <br>
 
 The full list of options are:
 <ul>
 <li>VERBOSITY_ALL: Accept all messages</li>
-<li>VERBOSITY_INFO_WARNING_ERROR: Accept messages at minimum level : INFO, WARNING, ERROR</li>
-<li>VERBOSITY_WARNING_ERROR: Accept messages at minimum level : WARNING, ERROR</li>
-<li>VERBOSITY_ERROR: Accept messages at minimum level : ERROR</li>
+<li>VERBOSITY_INFO_WARNING_ERROR: Accept messages at minimum level : INFO,
+WARNING, ERROR</li> <li>VERBOSITY_WARNING_ERROR: Accept messages at minimum
+level : WARNING, ERROR</li> <li>VERBOSITY_ERROR: Accept messages at minimum
+level : ERROR</li>
 </ul>
 
 
 \section sec_logger_tests Displaying messages
 
 Here is some example on how to display or record some information.
 \code
-      sendMsg("This is a message of level MSG_TYPE_DEBUG",MSG_TYPE_DEBUG, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_INFO",MSG_TYPE_INFO, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_WARNING",MSG_TYPE_WARNING, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_ERROR",MSG_TYPE_ERROR, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_DEBUG_STREAM",MSG_TYPE_DEBUG_STREAM, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_INFO_STREAM",MSG_TYPE_INFO_STREAM, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_WARNING_STREAM",MSG_TYPE_WARNING_STREAM, __FILE__,__LINE__);
-      sendMsg("This is a message of level MSG_TYPE_ERROR_STREAM",MSG_TYPE_ERROR_STREAM, __FILE__,__LINE__);
+      sendMsg("This is a message of level MSG_TYPE_DEBUG",MSG_TYPE_DEBUG,
+__FILE__,__LINE__); sendMsg("This is a message of level
+MSG_TYPE_INFO",MSG_TYPE_INFO, __FILE__,__LINE__); sendMsg("This is a message of
+level MSG_TYPE_WARNING",MSG_TYPE_WARNING, __FILE__,__LINE__); sendMsg("This is a
+message of level MSG_TYPE_ERROR",MSG_TYPE_ERROR, __FILE__,__LINE__);
+      sendMsg("This is a message of level
+MSG_TYPE_DEBUG_STREAM",MSG_TYPE_DEBUG_STREAM, __FILE__,__LINE__); sendMsg("This
+is a message of level MSG_TYPE_INFO_STREAM",MSG_TYPE_INFO_STREAM,
+__FILE__,__LINE__); sendMsg("This is a message of level
+MSG_TYPE_WARNING_STREAM",MSG_TYPE_WARNING_STREAM, __FILE__,__LINE__);
+      sendMsg("This is a message of level
+MSG_TYPE_ERROR_STREAM",MSG_TYPE_ERROR_STREAM, __FILE__,__LINE__);
 
       logger_.countdown();
 \endcode
 
-Specifying the file with __FILE__ and the line inside the file by __LINE__ are necessary for the
-STREAM messages. Indeed they are indexed using the two values. As the default value are "" and 0
-the counting will be confused.
+Specifying the file with __FILE__ and the line inside the file by __LINE__ are
+necessary for the STREAM messages. Indeed they are indexed using the two values.
+As the default value are "" and 0 the counting will be confused.
 */

doc/additionalDoc/debug-trace-doc.h

@@ -3,10 +3,10 @@
 
 \section subp_dbg_trace_intro Introduction
 The idea of this class and collection of MACROS is to specify
-a level for a message, and record the message in a stream according to this level.
-In addition there are mechanisms allowing that no time
-is wasted in condition test. You can therefore let the debugging messages
-inside the code without impact on performances.
+a level for a message, and record the message in a stream according to this
+level. In addition there are mechanisms allowing that no time is wasted in
+condition test. You can therefore let the debugging messages inside the code
+without impact on performances.
 
 \section subp_dbg_trace_set_on_macros Setting up dgDEBUG macros
 
@@ -31,12 +31,9 @@ are written is specified by:
 
 \section subp_dbg_trace_using_macros Using dgDEBUG macros
 
-To print that the beginning of a method is being executed use the following macros:
-\code
-    dgDEBUGIN(5);
-\endcode
-5 here specifies the minimum level that you be specified by VP_DEBUG_MODE for this message
-to be displayed.
+To print that the beginning of a method is being executed use the following
+macros: \code dgDEBUGIN(5); \endcode 5 here specifies the minimum level that you
+be specified by VP_DEBUG_MODE for this message to be displayed.
 
 It will generate the following output:
 \code
@@ -62,8 +59,8 @@ A message inside the code is written through:
 
 This generates the following output:
 \code
-/path_to/dynamic-graph/tests/debug-trace.cpp: testDebugTrace(#52) :Here is a test
-\endcode
+/path_to/dynamic-graph/tests/debug-trace.cpp: testDebugTrace(#52) :Here is a
+test \endcode
 
 \section subp_dbg_trace_wrk_exp Working example
 

doc/additionalDoc/entity.h

@@ -5,45 +5,57 @@
 \subsection entity_definition General definition
 \image html entity.png
 
-Despite the fact that it looks very similar to a ROS node or a CORBA/OpenRTM server, an entity is simply a C++ object.
-The main idea is that this entity is providing mostly a data-driven functionnality working at very high rate (\f$ 200
+Despite the fact that it looks very similar to a ROS node or a CORBA/OpenRTM
+server, an entity is simply a C++ object. The main idea is that this entity is
+providing mostly a data-driven functionnality working at very high rate (\f$ 200
 Hz\f$ or \f$ 1 kHz \f$) and should have a minimal computational time foot-print.
 
-For this \subpage subp_signals (or ports to use a more classical terminology) are providing a time dependency between
-data. To implement this, an output signal is linked with a method of the entity. The method calls input signals or use
-other means to get the needed data. It might be provided by the connection with remote computers through a middleware,
-or specific protocols, but in general the external data is based upon the sensor values provided by a "Device" entity.
-For this reason the signal evaluations are realized through the cascade of dependencies and start from the evaluation
-of an input signal of a periodic node (in general the device). This is realized inside a \b real-time thread.
-
-To add flexibility to a node, it is possible to add command with arguments to modify the internal behavior of the
-entity or get information from the entity. As a command is in general asynchronous and rare with respect to the
-data-flow scheme for the signals the command is in general executed in a \b none-real-time thread.
+For this \subpage subp_signals (or ports to use a more classical terminology)
+are providing a time dependency between data. To implement this, an output
+signal is linked with a method of the entity. The method calls input signals or
+use other means to get the needed data. It might be provided by the connection
+with remote computers through a middleware, or specific protocols, but in
+general the external data is based upon the sensor values provided by a "Device"
+entity. For this reason the signal evaluations are realized through the cascade
+of dependencies and start from the evaluation of an input signal of a periodic
+node (in general the device). This is realized inside a \b real-time thread.
+
+To add flexibility to a node, it is possible to add command with arguments to
+modify the internal behavior of the entity or get information from the entity.
+As a command is in general asynchronous and rare with respect to the data-flow
+scheme for the signals the command is in general executed in a \b none-real-time
+thread.
 
 \subsection entity_classes Entity class
-Entities are implemented as C++ classes and compiled as dynamic libraries. They can be loaded and instancied
-dynamically. It is therefore necessary to specify the location of their dynamical libraries. However given the time it
-might take to load the library, it is not advised to do that during a control-law computation. Entity instanciation
-also implies memory allocation which is also time consuming and thus not advised inside a real-time thread.
+Entities are implemented as C++ classes and compiled as dynamic libraries. They
+can be loaded and instancied dynamically. It is therefore necessary to specify
+the location of their dynamical libraries. However given the time it might take
+to load the library, it is not advised to do that during a control-law
+computation. Entity instanciation also implies memory allocation which is also
+time consuming and thus not advised inside a real-time thread.
 
-The entities will be placed in ${PREFIX}/lib/plugin (since this may change, it is advised to
-check the install log or the CMakeLists.txt file to check the installation path).
+The entities will be placed in ${PREFIX}/lib/plugin (since this may change, it
+is advised to check the install log or the CMakeLists.txt file to check the
+installation path).
 
 \subsection entities List of entities in this package
 Since most of the functionality in projects using the dynamic-graph framework
-is exposed from entities, here is a short description of all the entities contained in
-this package. Note that most entities are contained in a binary file that closely matches
-the entities' names in the scripts; loading this file with the plugin loader will
-enable creation of this entity through the factory.
+is exposed from entities, here is a short description of all the entities
+contained in this package. Note that most entities are contained in a binary
+file that closely matches the entities' names in the scripts; loading this file
+with the plugin loader will enable creation of this entity through the factory.
 \li \ref tracerdoc
 \li \ref tracerrealtimedoc
 
 \subsection specific_semantics Specific semantics with entities
 
-It is possible to derive classes and apply specific semantic for the entities. In our case we are interested in
-specific control semantics: \li Tasks (more information <a
-href="http://stack-of-tasks.github.io/sot-core/doxygen/HEAD/a00089.html">here</a>) \li Features (more information <a
-href="http://stack-of-tasks.github.io/sot-core/doxygen/HEAD/a00030.html">here</a>) \li Solver (more information <a
+It is possible to derive classes and apply specific semantic for the entities.
+In our case we are interested in specific control semantics: \li Tasks (more
+information <a
+href="http://stack-of-tasks.github.io/sot-core/doxygen/HEAD/a00089.html">here</a>)
+\li Features (more information <a
+href="http://stack-of-tasks.github.io/sot-core/doxygen/HEAD/a00030.html">here</a>)
+\li Solver (more information <a
 href="http://stack-of-tasks.github.io/sot-core/doxygen/HEAD/a00078.html">here</a>)
 
 */