From ed5899076b7b11c16d9517295e3826dd9b9d80d2 Mon Sep 17 00:00:00 2001
From: Guilhem Saurel <guilhem.saurel@laas.fr>
Date: Tue, 7 Sep 2021 16:44:33 +0200
Subject: [PATCH] reformat for clang-format-12
---
.clang-format | 200 +++++++
include/dynamic-graph/all-commands.h | 2 +-
include/dynamic-graph/all-signals.h | 2 +-
include/dynamic-graph/command-bind.h | 512 ++++++++++--------
include/dynamic-graph/command-direct-getter.h | 18 +-
include/dynamic-graph/command-direct-setter.h | 20 +-
include/dynamic-graph/command-getter.h | 15 +-
include/dynamic-graph/command-getter.t.cpp | 10 +-
include/dynamic-graph/command-setter.h | 15 +-
include/dynamic-graph/command-setter.t.cpp | 122 +++--
include/dynamic-graph/command.h | 17 +-
include/dynamic-graph/debug.h | 128 +++--
include/dynamic-graph/dynamic-graph-api.h | 2 +-
include/dynamic-graph/eigen-io.h | 28 +-
include/dynamic-graph/entity-helper.h | 7 +-
include/dynamic-graph/entity.h | 29 +-
include/dynamic-graph/exception-abstract.h | 39 +-
include/dynamic-graph/exception-factory.h | 10 +-
include/dynamic-graph/exception-signal.h | 7 +-
include/dynamic-graph/exception-traces.h | 10 +-
include/dynamic-graph/factory.h | 43 +-
include/dynamic-graph/fwd.hh | 35 +-
include/dynamic-graph/linear-algebra.h | 4 +-
include/dynamic-graph/logger.h | 84 ++-
include/dynamic-graph/pool.h | 20 +-
include/dynamic-graph/process-list.hh | 16 +-
include/dynamic-graph/real-time-logger-def.h | 33 +-
include/dynamic-graph/real-time-logger.h | 18 +-
include/dynamic-graph/signal-array.h | 53 +-
include/dynamic-graph/signal-base.h | 17 +-
include/dynamic-graph/signal-cast-helper.h | 2 +-
include/dynamic-graph/signal-caster.h | 29 +-
include/dynamic-graph/signal-helper.h | 48 +-
include/dynamic-graph/signal-ptr.h | 33 +-
include/dynamic-graph/signal-ptr.t.cpp | 28 +-
include/dynamic-graph/signal-time-dependent.h | 6 +-
include/dynamic-graph/signal.h | 28 +-
include/dynamic-graph/signal.t.cpp | 133 ++---
include/dynamic-graph/time-dependency.h | 19 +-
include/dynamic-graph/time-dependency.t.cpp | 60 +-
include/dynamic-graph/tracer-real-time.h | 22 +-
include/dynamic-graph/tracer.h | 25 +-
include/dynamic-graph/value.h | 23 +-
src/command/command.cpp | 8 +-
src/command/value.cpp | 359 ++++++------
src/debug/debug.cpp | 8 +-
src/debug/logger.cpp | 24 +-
src/debug/real-time-logger.cpp | 29 +-
src/dgraph/entity.cpp | 35 +-
src/dgraph/factory.cpp | 12 +-
src/dgraph/pool.cpp | 12 +-
src/exception/exception-abstract.cpp | 10 +-
src/exception/exception-factory.cpp | 3 +-
src/exception/exception-signal.cpp | 3 +-
src/exception/exception-traces.cpp | 3 +-
src/mt/process-list.cpp | 20 +-
src/traces/tracer-real-time.cpp | 18 +-
src/traces/tracer.cpp | 34 +-
tests/command-test.cpp | 18 +-
tests/custom-entity.cpp | 1 +
tests/debug-logger-winit.cpp | 13 +-
tests/debug-logger.cpp | 10 +-
tests/debug-real-time-tracer.cpp | 6 +-
tests/debug-trace.cpp | 19 +-
tests/debug-tracer.cpp | 6 +-
tests/entity.cpp | 12 +-
tests/exceptions.cpp | 6 +-
tests/factory.cpp | 5 +-
tests/interpreter-tracer.cpp | 1 +
tests/pool.cpp | 1 +
tests/real-time-logger.cpp | 6 +-
tests/signal-all.cpp | 5 +-
tests/signal-cast-registerer.cpp | 11 +-
tests/signal-ptr.cpp | 23 +-
tests/signal-time-dependent.cpp | 22 +-
tests/test-mt.cpp | 3 +-
tests/value.cpp | 49 +-
77 files changed, 1549 insertions(+), 1218 deletions(-)
diff --git a/.clang-format b/.clang-format
index 0e60482..b20f873 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,3 +1,203 @@
---
+Language: Cpp
+# BasedOnStyle: Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+ - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+ AfterCaseLabel: false
+ AfterClass: false
+ AfterControlStatement: Never
+ AfterEnum: false
+ AfterFunction: false
+ AfterNamespace: false
+ AfterObjCDeclaration: false
+ AfterStruct: false
+ AfterUnion: false
+ AfterExternBlock: false
+ BeforeCatch: false
+ BeforeElse: false
+ BeforeLambdaBody: false
+ BeforeWhile: false
+ IndentBraces: false
+ SplitEmptyFunction: true
+ SplitEmptyRecord: true
+ SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: true
+DisableFormat: false
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+ - foreach
+ - Q_FOREACH
+ - BOOST_FOREACH
+StatementAttributeLikeMacros:
+ - Q_EMIT
+IncludeBlocks: Regroup
+IncludeCategories:
+ - Regex: '^<pinocchio/fwd\.hpp>'
+ Priority: 1
+ SortPriority: 0
+ CaseSensitive: false
+ - Regex: '^<ext/.*\.h>'
+ Priority: 3
+ SortPriority: 0
+ CaseSensitive: false
+ - Regex: '^<.*\.h>'
+ Priority: 2
+ SortPriority: 0
+ CaseSensitive: false
+ - Regex: '^<.*'
+ Priority: 3
+ SortPriority: 0
+ CaseSensitive: false
+ - Regex: '.*'
+ Priority: 4
+ SortPriority: 0
+ CaseSensitive: false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires: false
+IndentWidth: 2
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+RawStringFormats:
+ - Language: Cpp
+ Delimiters:
+ - cc
+ - CC
+ - cpp
+ - Cpp
+ - CPP
+ - 'c++'
+ - 'C++'
+ CanonicalDelimiter: ''
+ BasedOnStyle: google
+ - Language: TextProto
+ Delimiters:
+ - pb
+ - PB
+ - proto
+ - PROTO
+ EnclosingFunctions:
+ - EqualsProto
+ - EquivToProto
+ - PARSE_PARTIAL_TEXT_PROTO
+ - PARSE_TEST_PROTO
+ - PARSE_TEXT_PROTO
+ - ParseTextOrDie
+ - ParseTextProtoOrDie
+ - ParseTestProto
+ - ParsePartialTestProto
+ CanonicalDelimiter: ''
+ BasedOnStyle: google
+ReflowComments: true
+SortIncludes: true
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard: Auto
+StatementMacros:
+ - Q_UNUSED
+ - QT_REQUIRE_VERSION
+TabWidth: 8
+UseCRLF: false
+UseTab: Never
+WhitespaceSensitiveMacros:
+ - STRINGIZE
+ - PP_STRINGIZE
+ - BOOST_PP_STRINGIZE
+ - NS_SWIFT_NAME
+ - CF_SWIFT_NAME
...
diff --git a/include/dynamic-graph/all-commands.h b/include/dynamic-graph/all-commands.h
index 7d34f8c..a655793 100644
--- a/include/dynamic-graph/all-commands.h
+++ b/include/dynamic-graph/all-commands.h
@@ -15,4 +15,4 @@
#include <dynamic-graph/command-setter.h>
#include <dynamic-graph/command.h>
-#endif //! DYNAMIC_GRAPH_ALL_COMMANDS_H
+#endif //! DYNAMIC_GRAPH_ALL_COMMANDS_H
diff --git a/include/dynamic-graph/all-signals.h b/include/dynamic-graph/all-signals.h
index d694ae3..d0b2a88 100644
--- a/include/dynamic-graph/all-signals.h
+++ b/include/dynamic-graph/all-signals.h
@@ -12,4 +12,4 @@
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/signal.h>
-#endif //! DYNAMIC_GRAPH_ALL_SIGNALS_H
+#endif //! DYNAMIC_GRAPH_ALL_SIGNALS_H
diff --git a/include/dynamic-graph/command-bind.h b/include/dynamic-graph/command-bind.h
index d28941e..629445c 100644
--- a/include/dynamic-graph/command-bind.h
+++ b/include/dynamic-graph/command-bind.h
@@ -20,28 +20,30 @@
*
*/
-#include "dynamic-graph/command.h"
#include <boost/assign/list_of.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
+#include "dynamic-graph/command.h"
+
/* --- FUNCTION 0 ARGS ----------------------------------------------------- */
namespace dynamicgraph {
namespace command {
-template <class E> struct CommandVoid0 : public Command {
+template <class E>
+struct CommandVoid0 : public Command {
CommandVoid0(E &entity, boost::function<void(void)> function,
const std::string &docString)
: Command(entity, EMPTY_ARG, docString), fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 0);
fptr();
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
boost::function<void(void)> fptr;
};
@@ -69,14 +71,15 @@ inline std::string docCommandVoid0(const std::string &doc) {
return std::string("\n") + doc + "\n\nNo input.\nVoid return.\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 1 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
namespace command {
-template <class E, typename T> struct CommandVoid1 : public Command {
+template <class E, typename T>
+struct CommandVoid1 : public Command {
typedef boost::function<void(const T &)> function_t;
CommandVoid1(E &entity, function_t function, const std::string &docString)
@@ -84,33 +87,33 @@ template <class E, typename T> struct CommandVoid1 : public Command {
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 1);
T val = getParameterValues()[0].value();
fptr(val);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
template <class E, typename T>
-CommandVoid1<E, T> *
-makeCommandVoid1(E &entity, boost::function<void(const T &)> function,
- // typename CommandVoid1<E,T>::function_t function ,
- const std::string &docString) {
+CommandVoid1<E, T> *makeCommandVoid1(
+ E &entity, boost::function<void(const T &)> function,
+ // typename CommandVoid1<E,T>::function_t function ,
+ const std::string &docString) {
return new CommandVoid1<E, T>(entity, function, docString);
}
template <class E, typename T>
-CommandVoid1<E, T> *
-makeCommandVoid1(E &entity,
- // The following syntaxt don't compile when not specializing
- // the template arg... why ???
- boost::function<void(E *, const T &)> function,
- const std::string &docString) {
+CommandVoid1<E, T> *makeCommandVoid1(
+ E &entity,
+ // The following syntaxt don't compile when not specializing
+ // the template arg... why ???
+ boost::function<void(E *, const T &)> function,
+ const std::string &docString) {
return new CommandVoid1<E, T>(entity, boost::bind(function, &entity, _1),
docString);
}
@@ -129,8 +132,8 @@ inline std::string docCommandVoid1(const std::string &doc,
".\nVoid return.\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 2 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
@@ -147,42 +150,42 @@ struct CommandVoid2 : public Command {
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 2);
T1 val1 = getParameterValues()[0].value();
T2 val2 = getParameterValues()[1].value();
fptr(val1, val2);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
template <class E, typename T1, typename T2>
-CommandVoid2<E, T1, T2> *
-makeCommandVoid2(E &entity,
- boost::function<void(const T1 &, const T2 &)> function,
- const std::string &docString) {
+CommandVoid2<E, T1, T2> *makeCommandVoid2(
+ E &entity, boost::function<void(const T1 &, const T2 &)> function,
+ const std::string &docString) {
return new CommandVoid2<E, T1, T2>(entity, function, docString);
}
template <class E, typename T1, typename T2>
-CommandVoid2<E, T1, T2> *
-makeCommandVoid2(E &entity,
- // The following syntaxt don't compile when not specializing
- // the template arg... why ???
- boost::function<void(E *, const T1 &, const T2 &)> function,
- const std::string &docString) {
+CommandVoid2<E, T1, T2> *makeCommandVoid2(
+ E &entity,
+ // The following syntaxt don't compile when not specializing
+ // the template arg... why ???
+ boost::function<void(E *, const T1 &, const T2 &)> function,
+ const std::string &docString) {
return new CommandVoid2<E, T1, T2>(
entity, boost::bind(function, &entity, _1, _2), docString);
}
template <class E, typename T1, typename T2>
-CommandVoid2<E, T1, T2> *
-makeCommandVoid2(E &entity, void (E::*function)(const T1 &, const T2 &),
- const std::string &docString) {
+CommandVoid2<E, T1, T2> *makeCommandVoid2(E &entity,
+ void (E::*function)(const T1 &,
+ const T2 &),
+ const std::string &docString) {
return new CommandVoid2<E, T1, T2>(
entity, boost::bind(function, &entity, _1, _2), docString);
return NULL;
@@ -195,8 +198,8 @@ inline std::string docCommandVoid2(const std::string &doc,
"Input:\n - A " + type2 + ".\n" + "Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 3 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
@@ -213,25 +216,24 @@ struct CommandVoid3 : public Command {
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 3);
T1 val1 = getParameterValues()[0].value();
T2 val2 = getParameterValues()[1].value();
T3 val3 = getParameterValues()[2].value();
fptr(val1, val2, val3);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
template <class E, typename T1, typename T2, typename T3>
-CommandVoid3<E, T1, T2, T3> *
-makeCommandVoid3(E &entity,
- typename CommandVoid3<E, T1, T2, T3>::function_t function,
- const std::string &docString) {
+CommandVoid3<E, T1, T2, T3> *makeCommandVoid3(
+ E &entity, typename CommandVoid3<E, T1, T2, T3>::function_t function,
+ const std::string &docString) {
return new CommandVoid3<E, T1, T2, T3>(entity, function, docString);
}
@@ -247,10 +249,9 @@ CommandVoid3<E, T1, T2, T3> *makeCommandVoid3(
}
template <class E, typename T1, typename T2, typename T3>
-CommandVoid3<E, T1, T2, T3> *
-makeCommandVoid3(E &entity,
- void (E::*function)(const T1 &, const T2 &, const T3 &),
- const std::string &docString) {
+CommandVoid3<E, T1, T2, T3> *makeCommandVoid3(
+ E &entity, void (E::*function)(const T1 &, const T2 &, const T3 &),
+ const std::string &docString) {
return new CommandVoid3<E, T1, T2, T3>(
entity, boost::bind(function, &entity, _1, _2, _3), docString);
return NULL;
@@ -265,8 +266,8 @@ inline std::string docCommandVoid3(const std::string &doc,
"Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 4 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
@@ -282,12 +283,12 @@ struct CommandVoid4 : public Command {
CommandVoid4(E &entity, function_t function, const std::string &docString)
: Command(entity,
boost::assign::list_of(ValueHelper<T1>::TypeID)(
- ValueHelper<T2>::TypeID)(ValueHelper<T3>::TypeID)(
- ValueHelper<T4>::TypeID),
+ ValueHelper<T2>::TypeID)(
+ ValueHelper<T3>::TypeID)(ValueHelper<T4>::TypeID),
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 4);
T1 val1 = getParameterValues()[0].value();
@@ -295,18 +296,17 @@ protected:
T3 val3 = getParameterValues()[2].value();
T4 val4 = getParameterValues()[3].value();
fptr(val1, val2, val3, val4);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
template <class E, typename T1, typename T2, typename T3, typename T4>
-CommandVoid4<E, T1, T2, T3, T4> *
-makeCommandVoid4(E &entity,
- typename CommandVoid4<E, T1, T2, T3, T4>::function_t function,
- const std::string &docString) {
+CommandVoid4<E, T1, T2, T3, T4> *makeCommandVoid4(
+ E &entity, typename CommandVoid4<E, T1, T2, T3, T4>::function_t function,
+ const std::string &docString) {
return new CommandVoid4<E, T1, T2, T3, T4>(entity, function, docString);
}
@@ -340,29 +340,33 @@ inline std::string docCommandVoid4(const std::string &doc,
"Input:\n - A " + type4 + ".\n" + "Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 5 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
namespace command {
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5>
struct CommandVoid5 : public Command {
- typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &)>
+ typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &)>
function_t;
typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
const T4 &, const T5 &);
CommandVoid5(E &entity, function_t function, const std::string &docString)
- : Command(entity,
- boost::assign::list_of(ValueHelper<T1>::TypeID)(
- ValueHelper<T2>::TypeID)(ValueHelper<T3>::TypeID)(
- ValueHelper<T4>::TypeID)(ValueHelper<T5>::TypeID),
- docString),
+ : Command(
+ entity,
+ boost::assign::list_of(ValueHelper<T1>::TypeID)(
+ ValueHelper<T2>::TypeID)(
+ ValueHelper<T3>::TypeID)(ValueHelper<T4>::TypeID)(ValueHelper<
+ T5>::TypeID),
+ docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 5);
T1 val1 = getParameterValues()[0].value();
@@ -371,35 +375,40 @@ protected:
T4 val4 = getParameterValues()[3].value();
T5 val5 = getParameterValues()[4].value();
fptr(val1, val2, val3, val4, val5);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
-CommandVoid5<E, T1, T2, T3, T4, T5> *
-makeCommandVoid5(E &entity,
- typename CommandVoid5<E, T1, T2, T3, T4, T5>::function_t function,
- const std::string &docString) {
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5>
+CommandVoid5<E, T1, T2, T3, T4, T5> *makeCommandVoid5(
+ E &entity,
+ typename CommandVoid5<E, T1, T2, T3, T4, T5>::function_t function,
+ const std::string &docString) {
return new CommandVoid5<E, T1, T2, T3, T4, T5>(entity, function, docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5>
CommandVoid5<E, T1, T2, T3, T4, T5> *makeCommandVoid5(
E &entity,
- boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &)>
+ boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &)>
function,
const std::string &docString) {
return new CommandVoid5<E, T1, T2, T3, T4, T5>(
entity, boost::bind(function, &entity, _1, _2, _3, _4, _5), docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5>
CommandVoid5<E, T1, T2, T3, T4, T5> *makeCommandVoid5(
E &entity,
- void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &),
+ void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &),
const std::string &docString) {
return new CommandVoid5<E, T1, T2, T3, T4, T5>(
entity, boost::bind(function, &entity, _1, _2, _3, _4, _5), docString);
@@ -418,30 +427,35 @@ inline std::string docCommandVoid5(const std::string &doc,
"Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 6 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
namespace command {
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6>
struct CommandVoid6 : public Command {
- typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &)>
+ typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &)>
function_t;
typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
const T4 &, const T5 &, const T6 &);
CommandVoid6(E &entity, function_t function, const std::string &docString)
- : Command(entity,
- boost::assign::list_of(ValueHelper<T1>::TypeID)(
- ValueHelper<T2>::TypeID)(ValueHelper<T3>::TypeID)(
- ValueHelper<T4>::TypeID)(ValueHelper<T5>::TypeID)(
- ValueHelper<T6>::TypeID),
- docString),
+ : Command(
+ entity,
+ boost::assign::list_of(ValueHelper<T1>::TypeID)(
+ ValueHelper<T2>::TypeID)(
+ ValueHelper<T3>::TypeID)(ValueHelper<
+ T4>::TypeID)(ValueHelper<T5>::
+ TypeID)(ValueHelper<
+ T6>::TypeID),
+ docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 6);
T1 val1 = getParameterValues()[0].value();
@@ -451,79 +465,91 @@ protected:
T5 val5 = getParameterValues()[4].value();
T6 val6 = getParameterValues()[5].value();
fptr(val1, val2, val3, val4, val5, val6);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-CommandVoid6<E, T1, T2, T3, T4, T5, T6> *
-makeCommandVoid6(E &entity,
- typename CommandVoid6<E, T1, T2, T3, T4, T5, T6>::function_t function,
- const std::string &docString) {
- return new CommandVoid6<E, T1, T2, T3, T4, T5, T6>(entity, function, docString);
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6>
+CommandVoid6<E, T1, T2, T3, T4, T5, T6> *makeCommandVoid6(
+ E &entity,
+ typename CommandVoid6<E, T1, T2, T3, T4, T5, T6>::function_t function,
+ const std::string &docString) {
+ return new CommandVoid6<E, T1, T2, T3, T4, T5, T6>(entity, function,
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6>
CommandVoid6<E, T1, T2, T3, T4, T5, T6> *makeCommandVoid6(
E &entity,
- boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &)>
+ boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &)>
function,
const std::string &docString) {
return new CommandVoid6<E, T1, T2, T3, T4, T5, T6>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6),
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6>
CommandVoid6<E, T1, T2, T3, T4, T5, T6> *makeCommandVoid6(
E &entity,
- void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &),
+ void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &),
const std::string &docString) {
return new CommandVoid6<E, T1, T2, T3, T4, T5, T6>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6),
+ docString);
return NULL;
}
-inline std::string docCommandVoid6(const std::string &doc,
- const std::string &type1,
- const std::string &type2,
- const std::string &type3,
- const std::string &type4,
- const std::string &type5,
- const std::string &type6) {
+inline std::string docCommandVoid6(
+ const std::string &doc, const std::string &type1, const std::string &type2,
+ const std::string &type3, const std::string &type4,
+ const std::string &type5, const std::string &type6) {
return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
"Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
"Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
"Input:\n - A " + type6 + ".\n" + "Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 7 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
namespace command {
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7>
struct CommandVoid7 : public Command {
- typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &)>
+ typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &)>
function_t;
typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
const T4 &, const T5 &, const T6 &,
const T7 &);
CommandVoid7(E &entity, function_t function, const std::string &docString)
- : Command(entity,
- boost::assign::list_of(ValueHelper<T1>::TypeID)(
- ValueHelper<T2>::TypeID)(ValueHelper<T3>::TypeID)(
- ValueHelper<T4>::TypeID)(ValueHelper<T5>::TypeID)(
- ValueHelper<T6>::TypeID)(ValueHelper<T7>::TypeID),
- docString),
+ : Command(
+ entity,
+ boost::assign::list_of(ValueHelper<T1>::TypeID)(
+ ValueHelper<T2>::TypeID)(
+ ValueHelper<T3>::
+ TypeID)(ValueHelper<
+ T4>::TypeID)(ValueHelper<T5>::
+ TypeID)(ValueHelper<T6>::
+ TypeID)(ValueHelper<
+ T7>::TypeID),
+ docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 7);
T1 val1 = getParameterValues()[0].value();
@@ -534,49 +560,54 @@ protected:
T6 val6 = getParameterValues()[5].value();
T7 val7 = getParameterValues()[6].value();
fptr(val1, val2, val3, val4, val5, val6, val7);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7> *
-makeCommandVoid7(E &entity,
- typename CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>::function_t function,
- const std::string &docString) {
- return new CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>(entity, function, docString);
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7>
+CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7> *makeCommandVoid7(
+ E &entity,
+ typename CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>::function_t function,
+ const std::string &docString) {
+ return new CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>(entity, function,
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7>
CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7> *makeCommandVoid7(
E &entity,
- boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &)>
+ boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &)>
function,
const std::string &docString) {
return new CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7),
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7>
CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7> *makeCommandVoid7(
E &entity,
- void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &),
+ void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &),
const std::string &docString) {
return new CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7),
+ docString);
return NULL;
}
-inline std::string docCommandVoid7(const std::string &doc,
- const std::string &type1,
- const std::string &type2,
- const std::string &type3,
- const std::string &type4,
- const std::string &type5,
- const std::string &type6,
- const std::string &type7) {
+inline std::string docCommandVoid7(
+ const std::string &doc, const std::string &type1, const std::string &type2,
+ const std::string &type3, const std::string &type4,
+ const std::string &type5, const std::string &type6,
+ const std::string &type7) {
return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
"Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
"Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
@@ -584,32 +615,41 @@ inline std::string docCommandVoid7(const std::string &doc,
"Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 8 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
namespace command {
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8>
struct CommandVoid8 : public Command {
- typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &)>
+ typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &, const T8 &)>
function_t;
typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
const T4 &, const T5 &, const T6 &,
const T7 &, const T8 &);
CommandVoid8(E &entity, function_t function, const std::string &docString)
- : Command(entity,
- boost::assign::list_of(ValueHelper<T1>::TypeID)(
- ValueHelper<T2>::TypeID)(ValueHelper<T3>::TypeID)(
- ValueHelper<T4>::TypeID)(ValueHelper<T5>::TypeID)(
- ValueHelper<T6>::TypeID)(ValueHelper<T7>::TypeID)(
- ValueHelper<T8>::TypeID),
- docString),
+ : Command(
+ entity,
+ boost::assign::list_of(ValueHelper<T1>::TypeID)(
+ ValueHelper<T2>::TypeID)(
+ ValueHelper<T3>::
+ TypeID)(ValueHelper<T4>::
+ TypeID)(ValueHelper<T5>::
+ TypeID)(ValueHelper<T6>::
+ TypeID)(ValueHelper<
+ T7>::
+ TypeID)(ValueHelper<
+ T8>::
+ TypeID),
+ docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 8);
T1 val1 = getParameterValues()[0].value();
@@ -621,50 +661,55 @@ protected:
T7 val7 = getParameterValues()[6].value();
T8 val8 = getParameterValues()[7].value();
fptr(val1, val2, val3, val4, val5, val6, val7, val8);
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
function_t fptr;
};
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8> *
-makeCommandVoid8(E &entity,
- typename CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>::function_t function,
- const std::string &docString) {
- return new CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>(entity, function, docString);
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8>
+CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8> *makeCommandVoid8(
+ E &entity,
+ typename CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>::function_t
+ function,
+ const std::string &docString) {
+ return new CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>(entity, function,
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8>
CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8> *makeCommandVoid8(
E &entity,
- boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &)>
+ boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &, const T8 &)>
function,
const std::string &docString) {
return new CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8),
+ docString);
}
-template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+template <class E, typename T1, typename T2, typename T3, typename T4,
+ typename T5, typename T6, typename T7, typename T8>
CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8> *makeCommandVoid8(
E &entity,
- void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &),
+ void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &,
+ const T5 &, const T6 &, const T7 &, const T8 &),
const std::string &docString) {
return new CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>(
- entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8), docString);
+ entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8),
+ docString);
return NULL;
}
-inline std::string docCommandVoid8(const std::string &doc,
- const std::string &type1,
- const std::string &type2,
- const std::string &type3,
- const std::string &type4,
- const std::string &type5,
- const std::string &type6,
- const std::string &type7,
- const std::string &type8) {
+inline std::string docCommandVoid8(
+ const std::string &doc, const std::string &type1, const std::string &type2,
+ const std::string &type3, const std::string &type4,
+ const std::string &type5, const std::string &type6,
+ const std::string &type7, const std::string &type8) {
return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
"Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
"Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
@@ -672,8 +717,8 @@ inline std::string docCommandVoid8(const std::string &doc,
"Input:\n - A " + type8 + ".\n" + "Void return.\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION VERBOSE ----------------------------------------------------- */
/* This bind a function void f( ostream& ) that display some results into
@@ -681,28 +726,29 @@ inline std::string docCommandVoid8(const std::string &doc,
namespace dynamicgraph {
namespace command {
-template <class E> struct CommandVerbose : public Command {
+template <class E>
+struct CommandVerbose : public Command {
typedef boost::function<void(std::ostream &)> function_t;
CommandVerbose(E &entity, function_t function, const std::string &docString)
: Command(entity, EMPTY_ARG, docString), fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 0);
std::ostringstream oss;
fptr(oss);
- return Value(oss.str()); // return string
+ return Value(oss.str()); // return string
}
-private:
+ private:
function_t fptr;
};
template <class E>
-CommandVerbose<E> *
-makeCommandVerbose(E &entity, typename CommandVerbose<E>::function_t function,
- const std::string &docString) {
+CommandVerbose<E> *makeCommandVerbose(
+ E &entity, typename CommandVerbose<E>::function_t function,
+ const std::string &docString) {
return new CommandVerbose<E>(entity, function, docString);
return NULL;
}
@@ -729,50 +775,48 @@ struct CommandReturnType0 : public Command {
const std::string &docString)
: Command(entity, EMPTY_ARG, docString), fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 0);
Value res(fptr());
return res;
}
-private:
+ private:
boost::function<ReturnType(void)> fptr;
};
template <class E, class ReturnType>
-CommandReturnType0<E, ReturnType> *
-makeCommandReturnType0(E &entity, boost::function<ReturnType(void)> function,
- const std::string &docString) {
+CommandReturnType0<E, ReturnType> *makeCommandReturnType0(
+ E &entity, boost::function<ReturnType(void)> function,
+ const std::string &docString) {
return new CommandReturnType0<E, ReturnType>(entity, function, docString);
}
template <class E, class ReturnType>
-CommandReturnType0<E, ReturnType> *
-makeCommandReturnType0(E &entity, boost::function<ReturnType(E *)> function,
- const std::string &docString) {
+CommandReturnType0<E, ReturnType> *makeCommandReturnType0(
+ E &entity, boost::function<ReturnType(E *)> function,
+ const std::string &docString) {
return new CommandReturnType0<E, ReturnType>(
entity, boost::bind(function, &entity), docString);
}
template <class E, class ReturnType>
-CommandReturnType0<E, ReturnType> *
-makeCommandReturnType0(E &entity, ReturnType (E::*function)(void),
- const std::string &docString) {
+CommandReturnType0<E, ReturnType> *makeCommandReturnType0(
+ E &entity, ReturnType (E::*function)(void), const std::string &docString) {
return new CommandReturnType0<E, ReturnType>(
entity, boost::bind(function, &entity), docString);
}
template <typename ReturnType>
-inline std::string
-docCommandReturnType0(const std::string &doc,
- const std::string & /* return_type */) {
+inline std::string docCommandReturnType0(
+ const std::string &doc, const std::string & /* return_type */) {
return std::string("\n") + doc + "\n\nNo input.\n" +
typeid(ReturnType).name() + " return.\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/* --- FUNCTION 1 ARGS ------------------------------------------------------ */
namespace dynamicgraph {
@@ -788,7 +832,7 @@ struct CommandReturnType1 : public Command {
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 1);
T val = getParameterValues()[0].value();
@@ -796,33 +840,32 @@ protected:
return res;
}
-private:
+ private:
function_t fptr;
};
template <class E, typename ReturnType, typename T>
-CommandReturnType1<E, ReturnType, T> *
-makeCommandReturnType1(E &entity,
- boost::function<ReturnType(const T &)> function,
- const std::string &docString) {
+CommandReturnType1<E, ReturnType, T> *makeCommandReturnType1(
+ E &entity, boost::function<ReturnType(const T &)> function,
+ const std::string &docString) {
return new CommandReturnType1<E, ReturnType, T>(entity, function, docString);
}
template <class E, typename ReturnType, typename T>
-CommandReturnType1<E, ReturnType, T> *
-makeCommandReturnType1(E &entity,
- // The following syntaxt don't compile when not
- // specializing the template arg... why ???
- boost::function<ReturnType(E *, const T &)> function,
- const std::string &docString) {
+CommandReturnType1<E, ReturnType, T> *makeCommandReturnType1(
+ E &entity,
+ // The following syntaxt don't compile when not
+ // specializing the template arg... why ???
+ boost::function<ReturnType(E *, const T &)> function,
+ const std::string &docString) {
return new CommandReturnType1<E, ReturnType, T>(
entity, boost::bind(function, &entity, _1), docString);
}
template <class E, typename ReturnType, typename T>
-CommandReturnType1<E, ReturnType, T> *
-makeCommandReturnType1(E &entity, ReturnType (E::*function)(const T &),
- const std::string &docString) {
+CommandReturnType1<E, ReturnType, T> *makeCommandReturnType1(
+ E &entity, ReturnType (E::*function)(const T &),
+ const std::string &docString) {
return new CommandReturnType1<E, ReturnType, T>(
entity, boost::bind(function, &entity, _1), docString);
return NULL;
@@ -835,8 +878,8 @@ inline std::string docCommandReturnType1(const std::string &doc,
typeid(ReturnType).name() + "return.\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
/*********** FUNCTION 2 Arguments ************************/
namespace dynamicgraph {
@@ -854,7 +897,7 @@ struct CommandReturnType2 : public Command {
docString),
fptr(function) {}
-protected:
+ protected:
virtual Value doExecute() {
assert(getParameterValues().size() == 2);
T1 val1 = getParameterValues()[0].value();
@@ -863,7 +906,7 @@ protected:
return res;
}
-private:
+ private:
function_t fptr;
};
@@ -887,10 +930,9 @@ CommandReturnType2<E, ReturnType, T1, T2> *makeCommandReturnType2(
}
template <class E, typename ReturnType, typename T1, typename T2>
-CommandReturnType2<E, ReturnType, T1, T2> *
-makeCommandReturnType2(E &entity,
- ReturnType (E::*function)(const T1 &, const T2 &),
- const std::string &docString) {
+CommandReturnType2<E, ReturnType, T1, T2> *makeCommandReturnType2(
+ E &entity, ReturnType (E::*function)(const T1 &, const T2 &),
+ const std::string &docString) {
return new CommandReturnType2<E, ReturnType, T1, T2>(
entity, boost::bind(function, &entity, _1, _2), docString);
return NULL;
@@ -905,7 +947,7 @@ inline std::string docCommandReturnType2(const std::string &doc,
"ReturnType:\n - Returns:" + typeid(ReturnType).name() + +".\n\n");
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // __dg_command_bind_h__
+#endif // __dg_command_bind_h__
diff --git a/include/dynamic-graph/command-direct-getter.h b/include/dynamic-graph/command-direct-getter.h
index 885718a..e9e39b4 100644
--- a/include/dynamic-graph/command-direct-getter.h
+++ b/include/dynamic-graph/command-direct-getter.h
@@ -15,15 +15,17 @@
*
*/
-#include "dynamic-graph/command.h"
#include <boost/assign/list_of.hpp>
+#include "dynamic-graph/command.h"
+
/* --- GETTER --------------------------------------------------------- */
namespace dynamicgraph {
namespace command {
-template <class E, typename T> class DirectGetter : public Command {
-public:
+template <class E, typename T>
+class DirectGetter : public Command {
+ public:
/// Pointer to method that sets parameter of type T
typedef T (E::*GetterMethod)() const;
@@ -31,10 +33,10 @@ public:
DirectGetter(E &entity, T *ptr, const std::string &docString)
: Command(entity, std::vector<Value::Type>(), docString), T_ptr(ptr) {}
-protected:
+ protected:
virtual Value doExecute() { return Value(*T_ptr); }
-private:
+ private:
T *T_ptr;
};
@@ -50,7 +52,7 @@ inline std::string docDirectGetter(const std::string &name,
type + ".\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // __dg_command_direct_getter_h__
+#endif // __dg_command_direct_getter_h__
diff --git a/include/dynamic-graph/command-direct-setter.h b/include/dynamic-graph/command-direct-setter.h
index 2765fa7..a81d2eb 100644
--- a/include/dynamic-graph/command-direct-setter.h
+++ b/include/dynamic-graph/command-direct-setter.h
@@ -15,29 +15,31 @@
*
*/
-#include "dynamic-graph/command.h"
#include <boost/assign/list_of.hpp>
+#include "dynamic-graph/command.h"
+
/* --- SETTER --------------------------------------------------------- */
namespace dynamicgraph {
namespace command {
-template <class E, typename T> class DirectSetter : public Command {
-public:
+template <class E, typename T>
+class DirectSetter : public Command {
+ public:
DirectSetter(E &entity, T *ptr, const std::string &docString)
: Command(entity, boost::assign::list_of(ValueHelper<T>::TypeID),
docString),
T_ptr(ptr) {}
-protected:
+ protected:
virtual Value doExecute() {
const std::vector<Value> &values = getParameterValues();
T val = values[0].value();
(*T_ptr) = val;
- return Value(); // void
+ return Value(); // void
}
-private:
+ private:
T *T_ptr;
};
@@ -53,7 +55,7 @@ inline std::string docDirectSetter(const std::string &name,
".\nVoid return.\n\n";
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // __dg_command_direct_setter_h__
+#endif // __dg_command_direct_setter_h__
diff --git a/include/dynamic-graph/command-getter.h b/include/dynamic-graph/command-getter.h
index beee09e..7414609 100644
--- a/include/dynamic-graph/command-getter.h
+++ b/include/dynamic-graph/command-getter.h
@@ -41,21 +41,22 @@ namespace command {
/// \li T should be a type supported by class Value,
/// \li prototype of E::getParameter should be exactly as specified in this
/// example.
-template <class E, typename T> class Getter : public Command {
-public:
+template <class E, typename T>
+class Getter : public Command {
+ public:
/// Pointer to method that sets parameter of type T
typedef T (E::*GetterMethod)() const;
/// Constructor
Getter(E &entity, GetterMethod getterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
GetterMethod getterMethod_;
};
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
#include "dynamic-graph/command-getter.t.cpp"
-#endif // DYNAMIC_GRAPH_COMMAND_GETTER_H
+#endif // DYNAMIC_GRAPH_COMMAND_GETTER_H
diff --git a/include/dynamic-graph/command-getter.t.cpp b/include/dynamic-graph/command-getter.t.cpp
index 8c5403e..6b4f2d9 100644
--- a/include/dynamic-graph/command-getter.t.cpp
+++ b/include/dynamic-graph/command-getter.t.cpp
@@ -8,6 +8,7 @@
#define DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP
#include "dynamic-graph/command-getter.h"
+
#include <sstream>
namespace dynamicgraph {
@@ -20,12 +21,13 @@ Getter<E, T>::Getter(E &entity, GetterMethod getterMethod,
: Command(entity, std::vector<Value::Type>(), docstring),
getterMethod_(getterMethod) {}
-template <class E, typename T> Value Getter<E, T>::doExecute() {
+template <class E, typename T>
+Value Getter<E, T>::doExecute() {
E &entity = static_cast<E &>(owner());
T value = (entity.*getterMethod_)();
return Value(value);
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP
+#endif // DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP
diff --git a/include/dynamic-graph/command-setter.h b/include/dynamic-graph/command-setter.h
index 4a20cb6..4fb1efd 100644
--- a/include/dynamic-graph/command-setter.h
+++ b/include/dynamic-graph/command-setter.h
@@ -41,21 +41,22 @@ namespace command {
/// \li T should be a type supported by class Value,
/// \li prototype of E::setParameter should be exactly as specified in this
/// example.
-template <class E, typename T> class Setter : public Command {
-public:
+template <class E, typename T>
+class Setter : public Command {
+ public:
/// Pointer to method that sets parameter of type T
typedef void (E::*SetterMethod)(const T &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
};
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
#include "dynamic-graph/command-setter.t.cpp"
-#endif // DYNAMIC_GRAPH_COMMAND_SETTER_H
+#endif // DYNAMIC_GRAPH_COMMAND_SETTER_H
diff --git a/include/dynamic-graph/command-setter.t.cpp b/include/dynamic-graph/command-setter.t.cpp
index d1972b1..f01e2fe 100644
--- a/include/dynamic-graph/command-setter.t.cpp
+++ b/include/dynamic-graph/command-setter.t.cpp
@@ -8,10 +8,12 @@
#define DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP
#include "dynamic-graph/command-setter.h"
-#include "dynamic-graph/linear-algebra.h"
+
#include <boost/assign/list_of.hpp>
#include <sstream>
+#include "dynamic-graph/linear-algebra.h"
+
namespace dynamicgraph {
class Entity;
namespace command {
@@ -19,19 +21,20 @@ namespace command {
//
// Template specialization: bool
//
-template <class E> class Setter<E, bool> : public Command {
-public:
+template <class E>
+class Setter<E, bool> : public Command {
+ public:
/// Pointer to method that sets parameter of type bool
typedef void (E::*SetterMethod)(const bool &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, bool>::Setter(E &entity, SetterMethod setterMethod,
@@ -39,7 +42,8 @@ Setter<E, bool>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::BOOL), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, bool>::doExecute() {
+template <class E>
+Value Setter<E, bool>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
bool value = values[0].value();
@@ -51,19 +55,20 @@ template <class E> Value Setter<E, bool>::doExecute() {
//
// Template specialization: unsigned
//
-template <class E> class Setter<E, unsigned> : public Command {
-public:
+template <class E>
+class Setter<E, unsigned> : public Command {
+ public:
/// Pointer to method that sets parameter of type unsigned
typedef void (E::*SetterMethod)(const unsigned &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, unsigned>::Setter(E &entity, SetterMethod setterMethod,
@@ -71,7 +76,8 @@ Setter<E, unsigned>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::UNSIGNED), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, unsigned>::doExecute() {
+template <class E>
+Value Setter<E, unsigned>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
unsigned value = values[0].value();
@@ -83,19 +89,20 @@ template <class E> Value Setter<E, unsigned>::doExecute() {
//
// Template specialization: int
//
-template <class E> class Setter<E, int> : public Command {
-public:
+template <class E>
+class Setter<E, int> : public Command {
+ public:
/// Pointer to method that sets parameter of type int
typedef void (E::*SetterMethod)(const int &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, int>::Setter(E &entity, SetterMethod setterMethod,
@@ -103,7 +110,8 @@ Setter<E, int>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::INT), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, int>::doExecute() {
+template <class E>
+Value Setter<E, int>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
int value = values[0].value();
@@ -115,19 +123,20 @@ template <class E> Value Setter<E, int>::doExecute() {
//
// Template specialization: float
//
-template <class E> class Setter<E, float> : public Command {
-public:
+template <class E>
+class Setter<E, float> : public Command {
+ public:
/// Pointer to method that sets parameter of type float
typedef void (E::*SetterMethod)(const float &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, float>::Setter(E &entity, SetterMethod setterMethod,
@@ -135,7 +144,8 @@ Setter<E, float>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::FLOAT), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, float>::doExecute() {
+template <class E>
+Value Setter<E, float>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
float value = values[0].value();
@@ -147,19 +157,20 @@ template <class E> Value Setter<E, float>::doExecute() {
//
// Template specialization: double
//
-template <class E> class Setter<E, double> : public Command {
-public:
+template <class E>
+class Setter<E, double> : public Command {
+ public:
/// Pointer to method that sets parameter of type double
typedef void (E::*SetterMethod)(const double &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, double>::Setter(E &entity, SetterMethod setterMethod,
@@ -167,7 +178,8 @@ Setter<E, double>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::DOUBLE), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, double>::doExecute() {
+template <class E>
+Value Setter<E, double>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
double value = values[0].value();
@@ -179,19 +191,20 @@ template <class E> Value Setter<E, double>::doExecute() {
//
// Template specialization: std::string
//
-template <class E> class Setter<E, std::string> : public Command {
-public:
+template <class E>
+class Setter<E, std::string> : public Command {
+ public:
/// Pointer to method that sets parameter of type std::string
typedef void (E::*SetterMethod)(const std::string &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, std::string>::Setter(E &entity, SetterMethod setterMethod,
@@ -199,7 +212,8 @@ Setter<E, std::string>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::STRING), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, std::string>::doExecute() {
+template <class E>
+Value Setter<E, std::string>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
std::string value = values[0].value();
@@ -211,19 +225,20 @@ template <class E> Value Setter<E, std::string>::doExecute() {
//
// Template specialization: Vector
//
-template <class E> class Setter<E, Vector> : public Command {
-public:
+template <class E>
+class Setter<E, Vector> : public Command {
+ public:
/// Pointer to method that sets parameter of type Vector
typedef void (E::*SetterMethod)(const Vector &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, Vector>::Setter(E &entity, SetterMethod setterMethod,
@@ -231,7 +246,8 @@ Setter<E, Vector>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::VECTOR), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, Vector>::doExecute() {
+template <class E>
+Value Setter<E, Vector>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
Vector value = values[0].value();
@@ -243,19 +259,20 @@ template <class E> Value Setter<E, Vector>::doExecute() {
//
// Template specialization: Matrix
//
-template <class E> class Setter<E, Matrix> : public Command {
-public:
+template <class E>
+class Setter<E, Matrix> : public Command {
+ public:
/// Pointer to method that sets parameter of type Matrix
typedef void (E::*SetterMethod)(const Matrix &);
/// Constructor
Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
-protected:
+ protected:
virtual Value doExecute();
-private:
+ private:
SetterMethod setterMethod_;
-}; // Class Setter
+}; // Class Setter
template <class E>
Setter<E, Matrix>::Setter(E &entity, SetterMethod setterMethod,
@@ -263,7 +280,8 @@ Setter<E, Matrix>::Setter(E &entity, SetterMethod setterMethod,
: Command(entity, boost::assign::list_of(Value::MATRIX), docString),
setterMethod_(setterMethod) {}
-template <class E> Value Setter<E, Matrix>::doExecute() {
+template <class E>
+Value Setter<E, Matrix>::doExecute() {
const std::vector<Value> &values = getParameterValues();
// Get parameter
Matrix value = values[0].value();
@@ -272,7 +290,7 @@ template <class E> Value Setter<E, Matrix>::doExecute() {
return Value();
}
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP
+#endif // DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP
diff --git a/include/dynamic-graph/command.h b/include/dynamic-graph/command.h
index 77a58d1..c304c6e 100644
--- a/include/dynamic-graph/command.h
+++ b/include/dynamic-graph/command.h
@@ -7,9 +7,10 @@
#ifndef DYNAMIC_GRAPH_COMMAND_H
#define DYNAMIC_GRAPH_COMMAND_H
+#include <vector>
+
#include "dynamic-graph/dynamic-graph-api.h"
#include "dynamic-graph/value.h"
-#include <vector>
namespace dynamicgraph {
class Entity;
@@ -32,7 +33,7 @@ namespace command {
/// vector of Values the types of which should fit the vector specified
/// at construction.
class DYNAMIC_GRAPH_DLLAPI Command {
-public:
+ public:
virtual ~Command();
/// Store the owner entity and a vector of value types
/// \param entity reference to Entity owning this command.
@@ -53,20 +54,20 @@ public:
/// Get documentation string
std::string getDocstring() const;
-protected:
+ protected:
/// Specific action performed by the command
virtual Value doExecute() = 0;
-private:
+ private:
Entity &owner_;
std::vector<Value::Type> valueTypeVector_;
std::vector<Value> valueVector_;
std::string docstring_;
-public:
+ public:
static const std::vector<Value::Type> EMPTY_ARG;
};
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // DYNAMIC_GRAPH_COMMAND_H
+#endif // DYNAMIC_GRAPH_COMMAND_H
diff --git a/include/dynamic-graph/debug.h b/include/dynamic-graph/debug.h
index 43a054c..27a2868 100644
--- a/include/dynamic-graph/debug.h
+++ b/include/dynamic-graph/debug.h
@@ -5,29 +5,29 @@
#ifndef DYNAMIC_GRAPH_DEBUG_HH
#define DYNAMIC_GRAPH_DEBUG_HH
+#include <dynamic-graph/dynamic-graph-api.h>
+
#include <cstdarg>
#include <cstdio>
+#include <dynamic-graph/fwd.hh>
#include <fstream>
#include <sstream>
-#include <dynamic-graph/dynamic-graph-api.h>
-#include <dynamic-graph/fwd.hh>
-
#ifndef VP_DEBUG_MODE
#define VP_DEBUG_MODE 0
-#endif //! VP_DEBUG_MODE
+#endif //! VP_DEBUG_MODE
#ifndef VP_TEMPLATE_DEBUG_MODE
#define VP_TEMPLATE_DEBUG_MODE 0
-#endif //! VP_TEMPLATE_DEBUG_MODE
-
-#define DG_COMMON_TRACES \
- do { \
- va_list arg; \
- va_start(arg, format); \
- vsnprintf(charbuffer, SIZE, format, arg); \
- va_end(arg); \
- outputbuffer << tmpbuffer.str() << charbuffer << std::endl; \
+#endif //! VP_TEMPLATE_DEBUG_MODE
+
+#define DG_COMMON_TRACES \
+ do { \
+ va_list arg; \
+ va_start(arg, format); \
+ vsnprintf(charbuffer, SIZE, format, arg); \
+ va_end(arg); \
+ outputbuffer << tmpbuffer.str() << charbuffer << std::endl; \
} while (0)
namespace dynamicgraph {
@@ -38,7 +38,7 @@ namespace dynamicgraph {
/// This class should never be used directly, please use the
/// debugging macro instead.
class DYNAMIC_GRAPH_DLLAPI DebugTrace {
-public:
+ public:
static const int SIZE = 512;
std::stringstream tmpbuffer;
@@ -50,8 +50,7 @@ public:
DebugTrace(std::ostream &os) : outputbuffer(os) {}
inline void trace(const int level, const char *format, ...) {
- if (level <= traceLevel)
- DG_COMMON_TRACES;
+ if (level <= traceLevel) DG_COMMON_TRACES;
tmpbuffer.str("");
}
@@ -68,8 +67,7 @@ public:
}
inline void traceTemplate(const int level, const char *format, ...) {
- if (level <= traceLevelTemplate)
- DG_COMMON_TRACES;
+ if (level <= traceLevelTemplate) DG_COMMON_TRACES;
tmpbuffer.str("");
}
@@ -92,57 +90,57 @@ public:
DYNAMIC_GRAPH_DLLAPI extern DebugTrace dgDEBUGFLOW;
DYNAMIC_GRAPH_DLLAPI extern DebugTrace dgERRORFLOW;
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
#ifdef VP_DEBUG
#define dgPREDEBUG __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
-#define dgPREERROR \
+#define dgPREERROR \
"\t!! " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
-#define dgDEBUG(level) \
- if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
- ; \
- else \
+#define dgDEBUG(level) \
+ if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+ ; \
+ else \
dgDEBUGFLOW.outputbuffer << dgPREDEBUG
-#define dgDEBUGMUTE(level) \
- if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
- ; \
- else \
+#define dgDEBUGMUTE(level) \
+ if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+ ; \
+ else \
dgDEBUGFLOW.outputbuffer
-#define dgERROR \
- if (!dgDEBUGFLOW.outputbuffer.good()) \
- ; \
- else \
+#define dgERROR \
+ if (!dgDEBUGFLOW.outputbuffer.good()) \
+ ; \
+ else \
dgERRORFLOW.outputbuffer << dgPREERROR
-#define dgDEBUGF \
- if (!dgDEBUGFLOW.outputbuffer.good()) \
- ; \
- else \
+#define dgDEBUGF \
+ if (!dgDEBUGFLOW.outputbuffer.good()) \
+ ; \
+ else \
dgDEBUGFLOW.pre(dgDEBUGFLOW.tmpbuffer << dgPREDEBUG, VP_DEBUG_MODE).trace
-#define dgERRORF \
- if (!dgDEBUGFLOW.outputbuffer.good()) \
- ; \
- else \
+#define dgERRORF \
+ if (!dgDEBUGFLOW.outputbuffer.good()) \
+ ; \
+ else \
dgERRORFLOW.pre(dgERRORFLOW.tmpbuffer << dgPREERROR).trace
// TEMPLATE
-#define dgTDEBUG(level) \
- if ((level > VP_TEMPLATE_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
- ; \
- else \
+#define dgTDEBUG(level) \
+ if ((level > VP_TEMPLATE_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+ ; \
+ else \
dgDEBUGFLOW.outputbuffer << dgPREDEBUG
-#define dgTDEBUGF \
- if (!dgDEBUGFLOW.outputbuffer.good()) \
- ; \
- else \
- dgDEBUGFLOW \
- .pre(dgDEBUGFLOW.tmpbuffer << dgPREDEBUG, VP_TEMPLATE_DEBUG_MODE) \
+#define dgTDEBUGF \
+ if (!dgDEBUGFLOW.outputbuffer.good()) \
+ ; \
+ else \
+ dgDEBUGFLOW \
+ .pre(dgDEBUGFLOW.tmpbuffer << dgPREDEBUG, VP_TEMPLATE_DEBUG_MODE) \
.trace
inline bool dgDEBUG_ENABLE(const int &level) { return level <= VP_DEBUG_MODE; }
@@ -151,19 +149,19 @@ inline bool dgTDEBUG_ENABLE(const int &level) {
return level <= VP_TEMPLATE_DEBUG_MODE;
}
-#else // VP_DEBUG
+#else // VP_DEBUG
-#define dgPREERROR \
+#define dgPREERROR \
"\t!! " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
-#define dgDEBUG(level) \
- if (1) \
- ; \
- else \
+#define dgDEBUG(level) \
+ if (1) \
+ ; \
+ else \
::dynamicgraph::__null_stream()
-#define dgDEBUGMUTE \
- (level) if (1); \
+#define dgDEBUGMUTE \
+ (level) if (1); \
else ::dynamicgraph::__null_stream()
#define dgERROR dgERRORFLOW.outputbuffer << dgPREERROR
@@ -183,13 +181,13 @@ inline std::ostream &__null_stream() {
static std::ostream os(NULL);
return os;
}
-} // namespace dynamicgraph
+} // namespace dynamicgraph
// TEMPLATE
-#define dgTDEBUG(level) \
- if (1) \
- ; \
- else \
+#define dgTDEBUG(level) \
+ if (1) \
+ ; \
+ else \
::dynamicgraph::__null_stream()
inline void dgTDEBUGF(const int, const char *, ...) { return; }
@@ -199,7 +197,7 @@ inline void dgTDEBUGF(const char *, ...) { return; }
#define dgDEBUG_ENABLE(level) false
#define dgTDEBUG_ENABLE(level) false
-#endif //! VP_DEBUG
+#endif //! VP_DEBUG
#define dgDEBUGIN(level) dgDEBUG(level) << "# In {" << std::endl
@@ -213,4 +211,4 @@ inline void dgTDEBUGF(const char *, ...) { return; }
#define dgTDEBUGINOUT(level) dgTDEBUG(level) << "# In/Out { }" << std::endl
-#endif //! DYNAMIC_GRAPH_DEBUG_HH
+#endif //! DYNAMIC_GRAPH_DEBUG_HH
diff --git a/include/dynamic-graph/dynamic-graph-api.h b/include/dynamic-graph/dynamic-graph-api.h
index 70fa0b2..88e281d 100644
--- a/include/dynamic-graph/dynamic-graph-api.h
+++ b/include/dynamic-graph/dynamic-graph-api.h
@@ -6,4 +6,4 @@
#ifndef DYNAMIC_GRAPH_API_H
#define DYNAMIC_GRAPH_API_H
#include <dynamic-graph/config.hh>
-#endif //! DYNAMIC_GRAPH_API_H
+#endif //! DYNAMIC_GRAPH_API_H
diff --git a/include/dynamic-graph/eigen-io.h b/include/dynamic-graph/eigen-io.h
index f4015b7..2d3f900 100644
--- a/include/dynamic-graph/eigen-io.h
+++ b/include/dynamic-graph/eigen-io.h
@@ -34,8 +34,9 @@ inline std::istringstream &operator>>(std::istringstream &iss,
unsigned int _size;
double _dbl_val;
char _ch;
- boost::format fmt("Failed to enter %s as vector."
- " Reenter as [N](val1,val2,val3,...,valN)");
+ boost::format fmt(
+ "Failed to enter %s as vector."
+ " Reenter as [N](val1,val2,val3,...,valN)");
fmt % iss.str();
if (iss >> _ch && _ch != '[') {
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
@@ -52,8 +53,7 @@ inline std::istringstream &operator>>(std::istringstream &iss,
else {
for (unsigned int i = 0; i < _size; i++) {
iss >> _dbl_val;
- if (iss.peek() == ',' || iss.peek() == ' ')
- iss.ignore();
+ if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
inst(i) = _dbl_val;
}
if (iss >> _ch && _ch != ')')
@@ -78,17 +78,17 @@ inline std::istringstream &operator>>(std::istringstream &iss,
unsigned int _rowsize;
double _dbl_val;
char _ch;
- boost::format fmt("Failed to enter %s as matrix. Reenter as "
- "((val11,val12,val13,...,val1N),"
- "...,(valM1,valM2,...,valMN))");
+ boost::format fmt(
+ "Failed to enter %s as matrix. Reenter as "
+ "((val11,val12,val13,...,val1N),"
+ "...,(valM1,valM2,...,valMN))");
MatrixXd _tmp_matrix;
fmt % iss.str();
if (iss >> _ch && _ch != '[') {
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
} else {
iss >> _rowsize;
- if (iss.peek() == ',' || iss.peek() == ' ')
- iss.ignore();
+ if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
iss >> _colsize;
if (iss.fail())
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
@@ -105,14 +105,12 @@ inline std::istringstream &operator>>(std::istringstream &iss,
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
for (unsigned int i = 0; i < _colsize; i++) {
iss >> _dbl_val;
- if (iss.peek() == ',' || iss.peek() == ' ')
- iss.ignore();
+ if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
_tmp_matrix(j, i) = _dbl_val;
}
if (iss >> _ch && _ch != ')')
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
- if (iss.peek() == ',' || iss.peek() == ' ')
- iss.ignore();
+ if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
}
if (iss >> _ch && _ch != ')')
throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
@@ -165,6 +163,6 @@ inline std::istringstream &operator>>(std::istringstream &iss,
return iss;
}
-} // namespace Eigen
+} // namespace Eigen
-#endif // DYNAMIC_GRAPH_EIGEN_IO_H
+#endif // DYNAMIC_GRAPH_EIGEN_IO_H
diff --git a/include/dynamic-graph/entity-helper.h b/include/dynamic-graph/entity-helper.h
index fb7c9ce..4be1b51 100644
--- a/include/dynamic-graph/entity-helper.h
+++ b/include/dynamic-graph/entity-helper.h
@@ -8,11 +8,12 @@
namespace dynamicgraph {
-template <typename Ent> struct EntityHelper {
+template <typename Ent>
+struct EntityHelper {
typedef Ent EntityClassName;
// static const std::string CLASS_NAME; TO BE ADDED IN DG DIRECTLY
};
-} // namespace dynamicgraph
+} // namespace dynamicgraph
-#endif // __sot_core_entity_helper_H__
+#endif // __sot_core_entity_helper_H__
diff --git a/include/dynamic-graph/entity.h b/include/dynamic-graph/entity.h
index b358606..acb2b86 100644
--- a/include/dynamic-graph/entity.h
+++ b/include/dynamic-graph/entity.h
@@ -5,20 +5,19 @@
#ifndef DYNAMIC_GRAPH_ENTITY_H
#define DYNAMIC_GRAPH_ENTITY_H
-#include <iosfwd>
-#include <map>
-#include <sstream>
-#include <string>
-
-#include <boost/noncopyable.hpp>
-
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-factory.h>
-#include <dynamic-graph/fwd.hh>
#include <dynamic-graph/logger.h>
#include <dynamic-graph/signal-array.h>
#include <dynamic-graph/signal-base.h>
+#include <boost/noncopyable.hpp>
+#include <dynamic-graph/fwd.hh>
+#include <iosfwd>
+#include <map>
+#include <sstream>
+#include <string>
+
/// \brief Helper macro for entity declaration.
///
/// This macro should be called in the declaration of all entities.
@@ -36,9 +35,9 @@
/// Caution: you *MUST* call DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN in the
/// associated source file to ensure that the attributes generated by
/// this macro are correctly initialized.
-#define DYNAMIC_GRAPH_ENTITY_DECL() \
-public: \
- virtual const std::string &getClassName() const { return CLASS_NAME; } \
+#define DYNAMIC_GRAPH_ENTITY_DECL() \
+ public: \
+ virtual const std::string &getClassName() const { return CLASS_NAME; } \
static const std::string CLASS_NAME
namespace dynamicgraph {
@@ -51,7 +50,7 @@ namespace dynamicgraph {
/// computation graph. To declare a new entity, please see the
/// DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN macro in factory.h.
class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
-public:
+ public:
typedef std::map<std::string, SignalBase<int> *> SignalMap;
typedef std::map<const std::string, command::Command *> CommandMap_t;
@@ -163,7 +162,7 @@ public:
/// \}
-protected:
+ protected:
void addCommand(const std::string &name, command::Command *command);
void entityRegistration();
@@ -180,6 +179,6 @@ protected:
DYNAMIC_GRAPH_DLLAPI std::ostream &operator<<(std::ostream &os,
const dynamicgraph::Entity &ent);
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_ENTITY_H
+#endif //! DYNAMIC_GRAPH_ENTITY_H
diff --git a/include/dynamic-graph/exception-abstract.h b/include/dynamic-graph/exception-abstract.h
index 0da0598..cd5e980 100644
--- a/include/dynamic-graph/exception-abstract.h
+++ b/include/dynamic-graph/exception-abstract.h
@@ -5,42 +5,47 @@
#ifndef DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
#define DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
-#include <string>
-
#include <dynamic-graph/dynamic-graph-api.h>
+
#include <dynamic-graph/fwd.hh>
+#include <string>
// Uncomment this macros to have lines parameter on the throw display
// #define DYNAMIC-GRAPH_EXCEPTION_PASSING_PARAM
-#define DG_RETHROW \
+#define DG_RETHROW \
(const ::dynamicgraph::ExceptionAbstract &err) { throw err; }
#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
-#define DG_THROW \
- throw ::dynamicgraph::ExceptionAbstract::Param(__LINE__, __FUNCTION__, \
+#define DG_THROW \
+ throw ::dynamicgraph::ExceptionAbstract::Param(__LINE__, __FUNCTION__, \
__FILE__) +
#else
#define DG_THROW throw
-#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
namespace dynamicgraph {
/// \ingroup error
///
/// \brief Abstract root class for all dynamic-graph exceptions.
class DYNAMIC_GRAPH_DLLAPI ExceptionAbstract : public std::exception {
-public:
+ public:
/// \ingroup error
///
/// \brief Class owned by exceptions to store error locations.
class Param {
- public:
+ public:
static const int BUFFER_SIZE = 80;
Param(const int &_line, const char *_function, const char *_file);
Param()
- : functionPTR(), function(), line(), filePTR(), file(),
- pointersSet(false), set(false) {}
+ : functionPTR(),
+ function(),
+ line(),
+ filePTR(),
+ file(),
+ pointersSet(false),
+ set(false) {}
Param &initCopy(const Param &p);
const char *functionPTR;
@@ -91,10 +96,10 @@ public:
}
/// \brief Print the error structure.
- DYNAMIC_GRAPH_DLLAPI friend std::ostream &
- operator<<(std::ostream &os, const ExceptionAbstract &err);
+ DYNAMIC_GRAPH_DLLAPI friend std::ostream &operator<<(
+ std::ostream &os, const ExceptionAbstract &err);
-protected:
+ protected:
/// \brief Error code.
/// \sa ErrorCodeEnum
int code;
@@ -121,12 +126,12 @@ protected:
return e;
}
-#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
-private:
+ private:
/// \brief Forbid the empty constructor (private).
ExceptionAbstract();
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
+#endif //! DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
diff --git a/include/dynamic-graph/exception-factory.h b/include/dynamic-graph/exception-factory.h
index 0275659..ec2e977 100644
--- a/include/dynamic-graph/exception-factory.h
+++ b/include/dynamic-graph/exception-factory.h
@@ -5,18 +5,18 @@
#ifndef DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
#define DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
-#include <string>
-
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-abstract.h>
+
#include <dynamic-graph/fwd.hh>
+#include <string>
namespace dynamicgraph {
/// \ingroup error
///
/// \brief Generic error class.
class DYNAMIC_GRAPH_DLLAPI ExceptionFactory : public ExceptionAbstract {
-public:
+ public:
enum ErrorCodeEnum {
GENERIC = ExceptionAbstract::FACTORY,
UNREFERED_OBJECT,
@@ -44,6 +44,6 @@ public:
return ExceptionFactory::EXCEPTION_NAME;
}
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
+#endif //! DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
diff --git a/include/dynamic-graph/exception-signal.h b/include/dynamic-graph/exception-signal.h
index a2fa44e..876097d 100644
--- a/include/dynamic-graph/exception-signal.h
+++ b/include/dynamic-graph/exception-signal.h
@@ -8,6 +8,7 @@
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-abstract.h>
+
#include <dynamic-graph/fwd.hh>
namespace dynamicgraph {
@@ -16,7 +17,7 @@ namespace dynamicgraph {
/// \brief Exceptions raised when an error related to signals
/// happen.
class DYNAMIC_GRAPH_DLLAPI ExceptionSignal : public ExceptionAbstract {
-public:
+ public:
enum ErrorCodeEnum {
GENERIC = ExceptionAbstract::SIGNAL,
READWRITE_LOCK,
@@ -38,6 +39,6 @@ public:
virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_EXCEPTION_SIGNAL_H
+#endif //! DYNAMIC_GRAPH_EXCEPTION_SIGNAL_H
diff --git a/include/dynamic-graph/exception-traces.h b/include/dynamic-graph/exception-traces.h
index de2b858..4f13200 100644
--- a/include/dynamic-graph/exception-traces.h
+++ b/include/dynamic-graph/exception-traces.h
@@ -5,18 +5,18 @@
#ifndef DYNAMIC_GRAPH_EXCEPTION_TRACES_H
#define DYNAMIC_GRAPH_EXCEPTION_TRACES_H
-#include <string>
-
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-abstract.h>
+
#include <dynamic-graph/fwd.hh>
+#include <string>
namespace dynamicgraph {
/// \ingroup error
///
/// \brief Exceptions raised when an error related to traces happen.
class DYNAMIC_GRAPH_DLLAPI ExceptionTraces : public ExceptionAbstract {
-public:
+ public:
enum ErrorCodeEnum { GENERIC = ExceptionAbstract::TRACES, NOT_OPEN };
static const std::string EXCEPTION_NAME;
@@ -29,6 +29,6 @@ public:
virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
};
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_EXCEPTION_TRACES_H
+#endif //! DYNAMIC_GRAPH_EXCEPTION_TRACES_H
diff --git a/include/dynamic-graph/factory.h b/include/dynamic-graph/factory.h
index 6c09ebd..8845685 100644
--- a/include/dynamic-graph/factory.h
+++ b/include/dynamic-graph/factory.h
@@ -5,15 +5,14 @@
#ifndef DYNAMIC_GRAPH_FACTORY_HH
#define DYNAMIC_GRAPH_FACTORY_HH
-#include <map>
-#include <string>
-#include <vector>
-
-#include <boost/noncopyable.hpp>
-
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-factory.h>
+
+#include <boost/noncopyable.hpp>
#include <dynamic-graph/fwd.hh>
+#include <map>
+#include <string>
+#include <vector>
/// \ingroup dgraph
///
@@ -24,16 +23,16 @@
/// \param CLASSNAME the name of the Entity to be registered (this must
/// be a std::string or a type implicitly castable into a std::string
/// such as classic C string delimited by double quotes).
-#define DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CLASSTYPE, CLASSNAME) \
- const std::string CLASSTYPE::CLASS_NAME = CLASSNAME; \
- extern "C" { \
- ::dynamicgraph::Entity * \
- EntityMaker_##CLASSTYPE(const std::string &objname) { \
- return new CLASSTYPE(objname); \
- } \
- ::dynamicgraph::EntityRegisterer reg_##CLASSTYPE(CLASSNAME, \
- &EntityMaker_##CLASSTYPE); \
- } \
+#define DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CLASSTYPE, CLASSNAME) \
+ const std::string CLASSTYPE::CLASS_NAME = CLASSNAME; \
+ extern "C" { \
+ ::dynamicgraph::Entity *EntityMaker_##CLASSTYPE( \
+ const std::string &objname) { \
+ return new CLASSTYPE(objname); \
+ } \
+ ::dynamicgraph::EntityRegisterer reg_##CLASSTYPE(CLASSNAME, \
+ &EntityMaker_##CLASSTYPE); \
+ } \
struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n
namespace dynamicgraph {
@@ -80,7 +79,7 @@ namespace dynamicgraph {
/// instance of this class enforces this behavior, instantiating one
/// yourself would break this property.
class DYNAMIC_GRAPH_DLLAPI FactoryStorage : private boost::noncopyable {
-public:
+ public:
/// \brief Function pointer providing an entity instance from its
/// name.
typedef Entity *(*EntityConstructor_ptr)(const std::string &);
@@ -151,7 +150,7 @@ public:
/// \param list Available entities will be appended to list.
void listEntities(std::vector<std::string> &list) const;
-private:
+ private:
/// \brief Constructor the factory.
///
/// After the initialization, no entities will be available.
@@ -183,7 +182,7 @@ private:
/// DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN macro and is of little interest
/// by itself.
class DYNAMIC_GRAPH_DLLAPI EntityRegisterer : private boost::noncopyable {
-public:
+ public:
/// \brief Register entity to the global factory.
explicit EntityRegisterer(const std::string &entityClassName,
FactoryStorage::EntityConstructor_ptr maker);
@@ -191,13 +190,13 @@ public:
/// \brief Unregister entity to the global factory.
~EntityRegisterer();
-private:
+ private:
/// \brief Name of the entity registered when the instance has
/// been initialized.
const std::string entityName;
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_FACTORY_HH
+#endif //! DYNAMIC_GRAPH_FACTORY_HH
// LocalWords: unregister
diff --git a/include/dynamic-graph/fwd.hh b/include/dynamic-graph/fwd.hh
index cfab3d9..54cb3f3 100644
--- a/include/dynamic-graph/fwd.hh
+++ b/include/dynamic-graph/fwd.hh
@@ -10,12 +10,12 @@
namespace dynamicgraph {
// to be replace by std:: when we switch to C++11 and later
-using boost::shared_ptr;
-using boost::weak_ptr;
-using boost::static_pointer_cast;
-using boost::dynamic_pointer_cast;
using boost::const_pointer_cast;
+using boost::dynamic_pointer_cast;
using boost::make_shared;
+using boost::shared_ptr;
+using boost::static_pointer_cast;
+using boost::weak_ptr;
class DebugTrace;
@@ -38,22 +38,29 @@ class PoolStorage;
class Tracer;
class TracerRealTime;
-template <typename T, typename Time> class Signal;
+template <typename T, typename Time>
+class Signal;
-template <typename Time> class SignalArray;
+template <typename Time>
+class SignalArray;
-template <typename Time> class SignalArray_const;
+template <typename Time>
+class SignalArray_const;
-template <typename Time> class SignalBase;
+template <typename Time>
+class SignalBase;
-template <typename T, typename Time> class SignalPtr;
-template <typename T, typename Time> class SignalTimeDependent;
-template <typename Time> class TimeDependency;
+template <typename T, typename Time>
+class SignalPtr;
+template <typename T, typename Time>
+class SignalTimeDependent;
+template <typename Time>
+class TimeDependency;
namespace command {
class Command;
-} // end of namespace command.
+} // end of namespace command.
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_FWD_HH
+#endif //! DYNAMIC_GRAPH_FWD_HH
diff --git a/include/dynamic-graph/linear-algebra.h b/include/dynamic-graph/linear-algebra.h
index 5808ec4..4a3b256 100644
--- a/include/dynamic-graph/linear-algebra.h
+++ b/include/dynamic-graph/linear-algebra.h
@@ -15,6 +15,6 @@
namespace dynamicgraph {
typedef Eigen::MatrixXd Matrix;
typedef Eigen::VectorXd Vector;
-} // namespace dynamicgraph
+} // namespace dynamicgraph
-#endif // DYNAMIC_GRAPH_LINEAR_ALGEBRA_H
+#endif // DYNAMIC_GRAPH_LINEAR_ALGEBRA_H
diff --git a/include/dynamic-graph/logger.h b/include/dynamic-graph/logger.h
index 278e7c2..41c1fee 100644
--- a/include/dynamic-graph/logger.h
+++ b/include/dynamic-graph/logger.h
@@ -27,19 +27,19 @@ namespace dynamicgraph {
/** Enum representing the different kind of messages.
*/
enum MsgType {
- MSG_TYPE_TYPE_BITS = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3, // 15
- MSG_TYPE_STREAM_BIT = 1 << 4, // 16
-
- MSG_TYPE_DEBUG = 1 << 3, // 1
- MSG_TYPE_INFO = 1 << 2, // 2
- MSG_TYPE_WARNING = 1 << 1, // 4
- MSG_TYPE_ERROR = 1 << 0, // 8
- MSG_TYPE_DEBUG_STREAM = MSG_TYPE_DEBUG | MSG_TYPE_STREAM_BIT, // 17
- MSG_TYPE_INFO_STREAM = MSG_TYPE_INFO | MSG_TYPE_STREAM_BIT, // 18
- MSG_TYPE_WARNING_STREAM = MSG_TYPE_WARNING | MSG_TYPE_STREAM_BIT, // 20
- MSG_TYPE_ERROR_STREAM = MSG_TYPE_ERROR | MSG_TYPE_STREAM_BIT // 24
+ MSG_TYPE_TYPE_BITS = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3, // 15
+ MSG_TYPE_STREAM_BIT = 1 << 4, // 16
+
+ MSG_TYPE_DEBUG = 1 << 3, // 1
+ MSG_TYPE_INFO = 1 << 2, // 2
+ MSG_TYPE_WARNING = 1 << 1, // 4
+ MSG_TYPE_ERROR = 1 << 0, // 8
+ MSG_TYPE_DEBUG_STREAM = MSG_TYPE_DEBUG | MSG_TYPE_STREAM_BIT, // 17
+ MSG_TYPE_INFO_STREAM = MSG_TYPE_INFO | MSG_TYPE_STREAM_BIT, // 18
+ MSG_TYPE_WARNING_STREAM = MSG_TYPE_WARNING | MSG_TYPE_STREAM_BIT, // 20
+ MSG_TYPE_ERROR_STREAM = MSG_TYPE_ERROR | MSG_TYPE_STREAM_BIT // 24
};
-} // namespace dynamicgraph
+} // namespace dynamicgraph
/* --------------------------------------------------------------------- */
/* --- INCLUDE --------------------------------------------------------- */
@@ -47,23 +47,22 @@ enum MsgType {
#include <map>
/// \todo These 3 headers should be removed.
-#include <fstream>
-#include <iomanip> // std::setprecision
-#include <sstream>
+#include <dynamic-graph/linear-algebra.h>
+#include <dynamic-graph/real-time-logger-def.h>
#include <boost/assign.hpp>
#include <boost/preprocessor/stringize.hpp>
-
#include <dynamic-graph/deprecated.hh>
-#include <dynamic-graph/linear-algebra.h>
-#include <dynamic-graph/real-time-logger-def.h>
+#include <fstream>
+#include <iomanip> // std::setprecision
+#include <sstream>
namespace dynamicgraph {
//#define LOGGER_VERBOSITY_INFO_WARNING_ERROR
#define LOGGER_VERBOSITY_ALL
-#define SEND_MSG(msg, type) \
+#define SEND_MSG(msg, type) \
sendMsg(msg, type, __FILE__ ":" BOOST_PP_STRINGIZE(__LINE__))
#define SEND_DEBUG_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_DEBUG_STREAM)
@@ -71,25 +70,25 @@ namespace dynamicgraph {
#define SEND_WARNING_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_WARNING_STREAM)
#define SEND_ERROR_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_ERROR_STREAM)
-#define _DYNAMIC_GRAPH_ENTITY_MSG(entity, type) \
+#define _DYNAMIC_GRAPH_ENTITY_MSG(entity, type) \
(entity).logger().stream(type, __FILE__ BOOST_PP_STRINGIZE(__LINE__))
-#define DYNAMIC_GRAPH_ENTITY_DEBUG(entity) \
+#define DYNAMIC_GRAPH_ENTITY_DEBUG(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_DEBUG)
-#define DYNAMIC_GRAPH_ENTITY_INFO(entity) \
+#define DYNAMIC_GRAPH_ENTITY_INFO(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_INFO)
-#define DYNAMIC_GRAPH_ENTITY_WARNING(entity) \
+#define DYNAMIC_GRAPH_ENTITY_WARNING(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_WARNING)
-#define DYNAMIC_GRAPH_ENTITY_ERROR(entity) \
+#define DYNAMIC_GRAPH_ENTITY_ERROR(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_ERROR)
-#define DYNAMIC_GRAPH_ENTITY_DEBUG_STREAM(entity) \
+#define DYNAMIC_GRAPH_ENTITY_DEBUG_STREAM(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_DEBUG_STREAM)
-#define DYNAMIC_GRAPH_ENTITY_INFO_STREAM(entity) \
+#define DYNAMIC_GRAPH_ENTITY_INFO_STREAM(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_INFO_STREAM)
-#define DYNAMIC_GRAPH_ENTITY_WARNING_STREAM(entity) \
+#define DYNAMIC_GRAPH_ENTITY_WARNING_STREAM(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_WARNING_STREAM)
-#define DYNAMIC_GRAPH_ENTITY_ERROR_STREAM(entity) \
+#define DYNAMIC_GRAPH_ENTITY_ERROR_STREAM(entity) \
_DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_ERROR_STREAM)
template <typename T>
@@ -185,7 +184,7 @@ enum LoggerVerbosity {
/// integer counting the number of calls. This will achieve exactly the
/// same behaviour without rouding numerical errors.
class Logger {
-public:
+ public:
/** Constructor */
Logger(double timeSample = 0.001, double streamPrintPeriod = 1.0);
@@ -211,8 +210,7 @@ public:
*/
RTLoggerStream stream(MsgType type, const std::string &lineId = "") {
RealTimeLogger &rtlogger = ::dynamicgraph::RealTimeLogger::instance();
- if (acceptMsg(type, lineId))
- return rtlogger.front();
+ if (acceptMsg(type, lineId)) return rtlogger.front();
return rtlogger.emptyStream();
}
@@ -221,16 +219,16 @@ public:
* stream(type, lineId) << msg << '\n';
* \endcode
*/
- [[deprecated("use stream(type, lineId) << msg")]] void
- sendMsg(std::string msg, MsgType type, const std::string &lineId = "");
+ [[deprecated("use stream(type, lineId) << msg")]] void sendMsg(
+ std::string msg, MsgType type, const std::string &lineId = "");
/** \deprecated instead, use
* \code
* stream(type, lineId) << msg << '\n';
* \endcode
*/
- [[deprecated("use stream(type, lineId) << msg")]] void
- sendMsg(std::string msg, MsgType type, const std::string &file, int line);
+ [[deprecated("use stream(type, lineId) << msg")]] void sendMsg(
+ std::string msg, MsgType type, const std::string &file, int line);
/** Set the sampling time at which the method countdown()
* is going to be called. */
@@ -252,11 +250,11 @@ public:
/** Get the verbosity level of the logger. */
LoggerVerbosity getVerbosity();
-protected:
- LoggerVerbosity m_lv; /// verbosity of the logger
+ protected:
+ LoggerVerbosity m_lv; /// verbosity of the logger
double m_timeSample;
/// specify the period of call of the countdown method
- double m_streamPrintPeriod; /// specify the time period of the stream prints
+ double m_streamPrintPeriod; /// specify the time period of the stream prints
double m_printCountdown;
/// every time this is < 0 (i.e. every _streamPrintPeriod sec) print stuff
@@ -273,12 +271,10 @@ protected:
*/
bool acceptMsg(MsgType m, const std::string &lineId) {
// If more verbose than the current verbosity level
- if ((m & MSG_TYPE_TYPE_BITS) > m_lv)
- return false;
+ if ((m & MSG_TYPE_TYPE_BITS) > m_lv) return false;
// if print is allowed by current verbosity level
- if (isStreamMsg(m))
- return checkStreamPeriod(lineId);
+ if (isStreamMsg(m)) return checkStreamPeriod(lineId);
return true;
}
@@ -288,6 +284,6 @@ protected:
bool checkStreamPeriod(const std::string &lineId);
};
-} // namespace dynamicgraph
+} // namespace dynamicgraph
-#endif // #ifndef __sot_torque_control_logger_H__
+#endif // #ifndef __sot_torque_control_logger_H__
diff --git a/include/dynamic-graph/pool.h b/include/dynamic-graph/pool.h
index 19f72aa..b9cbd2e 100644
--- a/include/dynamic-graph/pool.h
+++ b/include/dynamic-graph/pool.h
@@ -5,15 +5,15 @@
#ifndef DYNAMIC_GRAPH_POOL_H
#define DYNAMIC_GRAPH_POOL_H
-#include <map>
-#include <sstream>
-#include <string>
-
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-factory.h>
-#include <dynamic-graph/fwd.hh>
#include <dynamic-graph/signal-base.h>
+#include <dynamic-graph/fwd.hh>
+#include <map>
+#include <sstream>
+#include <string>
+
namespace dynamicgraph {
/*! @ingroup dgraph
\brief Singleton that keeps track of all the entities.
@@ -31,7 +31,7 @@ namespace dynamicgraph {
*/
class DYNAMIC_GRAPH_DLLAPI PoolStorage {
-public:
+ public:
/*! \name Define types to simplify the writing
@{
*/
@@ -98,7 +98,7 @@ public:
void writeGraph(const std::string &aFileName);
void writeCompletionList(std::ostream &os);
-protected:
+ protected:
/*! \name Fields of the class to manage the three entities.
Also the name is singular, those are true sets.
@{
@@ -106,13 +106,13 @@ protected:
/*! \brief Set of basic objects of the SoT */
Entities entityMap;
-private:
+ private:
PoolStorage() {}
static PoolStorage *instance_;
};
inline PoolStorage &g_pool() { return *PoolStorage::getInstance(); }
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_POOL_H
+#endif //! DYNAMIC_GRAPH_POOL_H
diff --git a/include/dynamic-graph/process-list.hh b/include/dynamic-graph/process-list.hh
index 94c4fc6..53b2f4b 100644
--- a/include/dynamic-graph/process-list.hh
+++ b/include/dynamic-graph/process-list.hh
@@ -6,11 +6,11 @@
#ifndef DYNAMIC_GRAPH_PROCESS_LIST_H_
#define DYNAMIC_GRAPH_PROCESS_LIST_H_
+#include <dynamic-graph/dynamic-graph-api.h>
+
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
-
-#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/fwd.hh>
namespace dynamicgraph {
@@ -18,14 +18,14 @@ namespace CPU {
class DYNAMIC_GRAPH_DLLAPI ProcessData {};
class DYNAMIC_GRAPH_DLLAPI ProcessList {
-public:
+ public:
ProcessList();
};
/// This class gather information on a specific CPU.
///
class DYNAMIC_GRAPH_DLLAPI CPUData {
-public:
+ public:
CPUData();
int cpu_id_;
@@ -126,10 +126,10 @@ public:
/// This class gathers information on a computer.
/// This includes a list of CPU
class DYNAMIC_GRAPH_DLLAPI System {
-private:
+ private:
bool init_;
-public:
+ public:
System();
/// Read /proc/state file to extract CPU count.
@@ -160,7 +160,7 @@ public:
ar &vCPUData_;
}
};
-} // namespace CPU
-} // namespace dynamicgraph
+} // namespace CPU
+} // namespace dynamicgraph
#endif /* DYNAMIC_GRAPH_PROCESS_LIST_H_ */
diff --git a/include/dynamic-graph/real-time-logger-def.h b/include/dynamic-graph/real-time-logger-def.h
index 86a2a26..eaa4cd0 100644
--- a/include/dynamic-graph/real-time-logger-def.h
+++ b/include/dynamic-graph/real-time-logger-def.h
@@ -4,13 +4,11 @@
#ifndef DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
#define DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
-#include <sstream>
-#include <vector>
-
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
-
#include <dynamic-graph/config.hh>
+#include <sstream>
+#include <vector>
namespace dynamicgraph {
/// \ingroup debug
@@ -21,7 +19,7 @@ namespace dynamicgraph {
/// want.
/// \sa LoggerIOStream
class LoggerStream {
-public:
+ public:
virtual void write(const char *c) = 0;
};
@@ -30,12 +28,12 @@ public:
/// The easieast is to use the macro dgADD_OSTREAM_TO_RTLOG(ostr) where
/// `ostr` can be `std::cout` or an std::ofstream...
class LoggerIOStream : public LoggerStream {
-public:
+ public:
LoggerIOStream(std::ostream &os) : os_(os) {}
virtual ~LoggerIOStream() {}
virtual void write(const char *c) { os_ << c; }
-private:
+ private:
std::ostream &os_;
};
typedef boost::shared_ptr<LoggerStream> LoggerStreamPtr_t;
@@ -48,17 +46,16 @@ class RealTimeLogger;
/// The entry starts when an instance is created and ends when is is deleted.
/// This class is only used by RealTimeLogger.
class RTLoggerStream {
-public:
+ public:
inline RTLoggerStream(RealTimeLogger *logger, std::ostream &os)
: ok_(logger != NULL), logger_(logger), os_(os) {}
- template <typename T> inline RTLoggerStream &operator<<(T t) {
- if (ok_)
- os_ << t;
+ template <typename T>
+ inline RTLoggerStream &operator<<(T t) {
+ if (ok_) os_ << t;
return *this;
}
inline RTLoggerStream &operator<<(std::ostream &(*pf)(std::ostream &)) {
- if (ok_)
- os_ << pf;
+ if (ok_) os_ << pf;
return *this;
}
@@ -66,7 +63,7 @@ public:
inline bool isNull() { return !ok_; }
-private:
+ private:
const bool ok_;
RealTimeLogger *logger_;
std::ostream &os_;
@@ -97,7 +94,7 @@ private:
/// - one writer at a time. Writing to the logs is **never** a blocking
/// operation. If the resource is busy, the log entry is discarded.
class DYNAMIC_GRAPH_DLLAPI RealTimeLogger {
-public:
+ public:
static RealTimeLogger &instance();
static void destroy();
@@ -146,7 +143,7 @@ public:
~RealTimeLogger();
-private:
+ private:
struct Data {
std::stringbuf buf;
};
@@ -177,6 +174,6 @@ RTLoggerStream::~RTLoggerStream() {
}
}
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
+#endif //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
diff --git a/include/dynamic-graph/real-time-logger.h b/include/dynamic-graph/real-time-logger.h
index 790fe34..15f12a6 100644
--- a/include/dynamic-graph/real-time-logger.h
+++ b/include/dynamic-graph/real-time-logger.h
@@ -6,21 +6,21 @@
#define DYNAMIC_GRAPH_LOGGER_REAL_TIME_H
#ifdef ENABLE_RT_LOG
-#define dgADD_OSTREAM_TO_RTLOG(ostr) \
- ::dynamicgraph::RealTimeLogger::instance().addOutputStream( \
- ::dynamicgraph::LoggerStreamPtr_t( \
+#define dgADD_OSTREAM_TO_RTLOG(ostr) \
+ ::dynamicgraph::RealTimeLogger::instance().addOutputStream( \
+ ::dynamicgraph::LoggerStreamPtr_t( \
new ::dynamicgraph::LoggerIOStream(ostr)))
#define dgRTLOG() ::dynamicgraph::RealTimeLogger::instance().front()
-#else // ENABLE_RT_LOG
+#else // ENABLE_RT_LOG
#define dgADD_OSTREAM_TO_RTLOG(ostr) struct __end_with_semicolon
-#define dgRTLOG() \
- if (1) \
- ; \
- else \
+#define dgRTLOG() \
+ if (1) \
+ ; \
+ else \
__null_stream()
#endif
#include <dynamic-graph/real-time-logger-def.h>
-#endif //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_H
+#endif //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_H
diff --git a/include/dynamic-graph/signal-array.h b/include/dynamic-graph/signal-array.h
index 15ebdd5..151c505 100644
--- a/include/dynamic-graph/signal-array.h
+++ b/include/dynamic-graph/signal-array.h
@@ -8,6 +8,7 @@
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/signal-base.h>
#include <stdio.h>
+
#include <vector>
namespace dynamicgraph {
@@ -15,16 +16,16 @@ namespace dynamicgraph {
/// \ingroup dgraph
///
/// \brief TODO
-template <class Time> class SignalArray_const {
-
-public:
+template <class Time>
+class SignalArray_const {
+ public:
static const int DEFAULT_SIZE = 20;
-protected:
+ protected:
std::vector<const SignalBase<Time> *> const_array;
unsigned int size, rank;
-public:
+ public:
SignalArray_const<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
: const_array(sizeARG), size(sizeARG), rank(0) {}
@@ -34,22 +35,22 @@ public:
}
SignalArray_const<Time>(const SignalArray<Time> &siga)
- : const_array(siga.getSize()), size(siga.getSize()),
+ : const_array(siga.getSize()),
+ size(siga.getSize()),
rank(siga.getSize()) {
- for (unsigned int i = 0; i < rank; ++i)
- const_array[i] = &siga[i];
+ for (unsigned int i = 0; i < rank; ++i) const_array[i] = &siga[i];
}
SignalArray_const<Time>(const SignalArray_const<Time> &siga)
- : const_array(siga.getSize()), size(siga.getSize()),
+ : const_array(siga.getSize()),
+ size(siga.getSize()),
rank(siga.getSize()) {
- for (unsigned int i = 0; i < rank; ++i)
- const_array[i] = &siga[i];
+ for (unsigned int i = 0; i < rank; ++i) const_array[i] = &siga[i];
}
virtual ~SignalArray_const<Time>() {}
-protected:
+ protected:
void addElmt(const SignalBase<Time> *el) {
if (rank >= size) {
size += DEFAULT_SIZE;
@@ -58,13 +59,13 @@ protected:
const_array[rank++] = el;
}
-public:
+ public:
virtual SignalArray_const<Time> &operator<<(const SignalBase<Time> &sig) {
addElmt(&sig);
return *this;
}
-public:
+ public:
virtual const SignalBase<Time> &operator[](const unsigned int &idx) const {
return *const_array[idx];
}
@@ -82,16 +83,17 @@ SignalArray_const<Time> operator<<(const SignalBase<Time> &sig1,
/// \ingroup dgraph
///
/// \brief TODO
-template <class Time> class SignalArray : public SignalArray_const<Time> {
-public:
+template <class Time>
+class SignalArray : public SignalArray_const<Time> {
+ public:
using SignalArray_const<Time>::DEFAULT_SIZE;
using SignalArray_const<Time>::size;
using SignalArray_const<Time>::rank;
-protected:
+ protected:
mutable std::vector<SignalBase<Time> *> array;
-public:
+ public:
SignalArray<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
: SignalArray_const<Time>(0), array(sizeARG) {
size = sizeARG;
@@ -106,13 +108,12 @@ public:
SignalArray<Time>(const SignalArray<Time> &siga)
: SignalArray_const<Time>(siga.getSize()), array(siga.getSize()) {
rank = siga.getSize();
- for (unsigned int i = 0; i < rank; ++i)
- array[i] = &siga[i];
+ for (unsigned int i = 0; i < rank; ++i) array[i] = &siga[i];
}
virtual ~SignalArray<Time>() {}
-protected:
+ protected:
void addElmt(SignalBase<Time> *el) {
if (rank >= size) {
size += DEFAULT_SIZE;
@@ -121,14 +122,14 @@ protected:
array[rank++] = el;
}
-public:
+ public:
virtual SignalArray<Time> &operator<<(SignalBase<Time> &sig) {
addElmt(&sig);
return *this;
}
- virtual SignalArray_const<Time>
- operator<<(const SignalBase<Time> &sig) const {
+ virtual SignalArray_const<Time> operator<<(
+ const SignalBase<Time> &sig) const {
SignalArray_const<Time> res(*this);
res << sig;
return res;
@@ -148,6 +149,6 @@ SignalArray<Time> operator<<(SignalBase<Time> &sig1, SignalBase<Time> &sig2) {
DYNAMIC_GRAPH_DLLAPI extern SignalArray<int> sotNOSIGNAL;
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_SIGNAL_ARRAY_H
+#endif //! DYNAMIC_GRAPH_SIGNAL_ARRAY_H
diff --git a/include/dynamic-graph/signal-base.h b/include/dynamic-graph/signal-base.h
index e0d8373..a260a8e 100644
--- a/include/dynamic-graph/signal-base.h
+++ b/include/dynamic-graph/signal-base.h
@@ -6,14 +6,14 @@
#ifndef DYNAMIC_GRAPH_SIGNAL_BASE_H
#define DYNAMIC_GRAPH_SIGNAL_BASE_H
+#include <dynamic-graph/exception-signal.h>
+
#include <boost/noncopyable.hpp>
+#include <dynamic-graph/fwd.hh>
#include <sstream>
#include <string>
#include <typeinfo>
-#include <dynamic-graph/exception-signal.h>
-#include <dynamic-graph/fwd.hh>
-
namespace dynamicgraph {
/** \brief The base class for signals: not to be used as such.
@@ -23,8 +23,9 @@ namespace dynamicgraph {
value of the signal, which can involve an extra computation,
while the latter accesses a cached value, or 'copy'.
*/
-template <class Time> class SignalBase : public boost::noncopyable {
-public:
+template <class Time>
+class SignalBase : public boost::noncopyable {
+ public:
explicit SignalBase(std::string name = "")
: name(name), signalTime(0), ready(false) {}
@@ -195,7 +196,7 @@ public:
}
/// \}
-protected:
+ protected:
std::string name;
Time signalTime;
bool ready;
@@ -206,6 +207,6 @@ template <class Time>
std::ostream &operator<<(std::ostream &os, const SignalBase<Time> &sig) {
return sig.display(os);
}
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_SIGNAL_BASE_H
+#endif //! DYNAMIC_GRAPH_SIGNAL_BASE_H
diff --git a/include/dynamic-graph/signal-cast-helper.h b/include/dynamic-graph/signal-cast-helper.h
index 00e6c7a..ea8dfc7 100644
--- a/include/dynamic-graph/signal-cast-helper.h
+++ b/include/dynamic-graph/signal-cast-helper.h
@@ -8,4 +8,4 @@
#pragma warning "This file is now useless"
-#endif // #ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HELPER_HH
+#endif // #ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HELPER_HH
diff --git a/include/dynamic-graph/signal-caster.h b/include/dynamic-graph/signal-caster.h
index edc15be..3a7255a 100644
--- a/include/dynamic-graph/signal-caster.h
+++ b/include/dynamic-graph/signal-caster.h
@@ -4,22 +4,23 @@
#ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HH
#define DYNAMIC_GRAPH_SIGNAL_CASTER_HH
-#include <map>
-#include <vector>
+#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/eigen-io.h>
+#include <dynamic-graph/linear-algebra.h>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
+#include <map>
+#include <vector>
#include "dynamic-graph/exception-signal.h"
-#include <dynamic-graph/dynamic-graph-api.h>
-#include <dynamic-graph/eigen-io.h>
-#include <dynamic-graph/linear-algebra.h>
namespace dynamicgraph {
/// Inherit from this class if you want to keep default implementation for some
/// functions.
-template <typename T> struct signal_io_base {
+template <typename T>
+struct signal_io_base {
/// serialize a signal value.
inline static void disp(const T &value, std::ostream &os) { os << value; }
/// deserialize a signal value.
@@ -37,7 +38,8 @@ template <typename T> struct signal_io_base {
};
/// Inherit from this class if tracing is not implemented for a given type.
-template <typename T> struct signal_io_unimplemented {
+template <typename T>
+struct signal_io_unimplemented {
inline static void disp(const T &, std::ostream &) {
throw std::logic_error("this disp is not implemented.");
}
@@ -50,7 +52,8 @@ template <typename T> struct signal_io_unimplemented {
};
/// Class used for I/O operations in Signal<T,Time>
-template <typename T> struct signal_io : signal_io_base<T> {};
+template <typename T>
+struct signal_io : signal_io_base<T> {};
/// Template specialization of signal_disp for Eigen objects
template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
@@ -98,7 +101,8 @@ struct signal_io<Eigen::Quaternion<_Scalar, _Options>>
/// Template specialization of signal_io for std::string.
/// Do not print '\n' at the end.
-template <> struct signal_io<std::string> : signal_io_base<std::string> {
+template <>
+struct signal_io<std::string> : signal_io_base<std::string> {
inline static std::string cast(std::istringstream &iss) { return iss.str(); }
};
@@ -114,7 +118,8 @@ template <> struct signal_io<std::string> : signal_io_base<std::string> {
/// To workaround this problem, parse special values manually
/// (the strings used are the one produces by displaying special
/// values on a stream).
-template <> struct signal_io<double> : signal_io_base<double> {
+template <>
+struct signal_io<double> : signal_io_base<double> {
inline static double cast(std::istringstream &iss) {
std::string tmp(iss.str());
@@ -135,6 +140,6 @@ template <> struct signal_io<double> : signal_io_base<double> {
}
};
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_SIGNAL_CASTER_HH
+#endif //! DYNAMIC_GRAPH_SIGNAL_CASTER_HH
diff --git a/include/dynamic-graph/signal-helper.h b/include/dynamic-graph/signal-helper.h
index 04bac13..c3db75f 100644
--- a/include/dynamic-graph/signal-helper.h
+++ b/include/dynamic-graph/signal-helper.h
@@ -19,18 +19,18 @@
/* --- MACROS ---------------------------------------------------------- */
#define SIGNAL_OUT_FUNCTION_NAME(name) name##SOUT_function
-#define DECLARE_SIGNAL(name, IO, type) \
+#define DECLARE_SIGNAL(name, IO, type) \
::dynamicgraph::Signal<type, int> m_##name##S##IO
-#define CONSTRUCT_SIGNAL(name, IO, type) \
- m_##name##S##IO(getClassName() + "(" + getName() + ")::" + #IO + "put(" + \
+#define CONSTRUCT_SIGNAL(name, IO, type) \
+ m_##name##S##IO(getClassName() + "(" + getName() + ")::" + #IO + "put(" + \
#type + ")::" + #name)
-#define BIND_SIGNAL_TO_FUNCTION(name, IO, type) \
- m_##name##S##IO.setFunction(boost::bind( \
+#define BIND_SIGNAL_TO_FUNCTION(name, IO, type) \
+ m_##name##S##IO.setFunction(boost::bind( \
&EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name), this, _1, _2));
/**/
-#define DECLARE_SIGNAL_IN(name, type) \
+#define DECLARE_SIGNAL_IN(name, type) \
::dynamicgraph::SignalPtr<type, int> m_##name##SIN
#define CONSTRUCT_SIGNAL_IN(name, type) \
m_##name##SIN(NULL, getClassName() + "(" + getName() + ")::input(" + #type + \
@@ -38,40 +38,40 @@
/**/
-#define DECLARE_SIGNAL_OUT_FUNCTION(name, type) \
+#define DECLARE_SIGNAL_OUT_FUNCTION(name, type) \
type &SIGNAL_OUT_FUNCTION_NAME(name)(type &, int)
-#define DEFINE_SIGNAL_OUT_FUNCTION(name, type) \
+#define DEFINE_SIGNAL_OUT_FUNCTION(name, type) \
type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, int iter)
#define SIGNAL_OUT_FUNCTION(name) name##SOUT_function
-#define DECLARE_SIGNAL_OUT(name, type) \
-public: \
- ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SOUT; \
- \
-protected: \
+#define DECLARE_SIGNAL_OUT(name, type) \
+ public: \
+ ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SOUT; \
+ \
+ protected: \
type &SIGNAL_OUT_FUNCTION(name)(type &, int)
-#define CONSTRUCT_SIGNAL_OUT(name, type, dep) \
- m_##name##SOUT( \
- boost::bind(&EntityClassName::name##SOUT_function, this, _1, _2), dep, \
+#define CONSTRUCT_SIGNAL_OUT(name, type, dep) \
+ m_##name##SOUT( \
+ boost::bind(&EntityClassName::name##SOUT_function, this, _1, _2), dep, \
getClassName() + "(" + getName() + ")::output(" + #type + ")::" + #name)
/**************** INNER SIGNALS *******************/
#define SIGNAL_INNER_FUNCTION_NAME(name) name##SINNER_function
-#define DECLARE_SIGNAL_INNER_FUNCTION(name, type) \
+#define DECLARE_SIGNAL_INNER_FUNCTION(name, type) \
type &SIGNAL_INNER_FUNCTION_NAME(name)(type &, int)
-#define DEFINE_SIGNAL_INNER_FUNCTION(name, type) \
+#define DEFINE_SIGNAL_INNER_FUNCTION(name, type) \
type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, int iter)
-#define DECLARE_SIGNAL_INNER(name, type) \
-public: \
- ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SINNER; \
- \
-protected: \
+#define DECLARE_SIGNAL_INNER(name, type) \
+ public: \
+ ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SINNER; \
+ \
+ protected: \
DECLARE_SIGNAL_INNER_FUNCTION(name, type)
#define CONSTRUCT_SIGNAL_INNER(name, type, dep) \
@@ -79,4 +79,4 @@ protected: \
boost::bind(&EntityClassName::name##SINNER_function, this, _1, _2), dep, \
getClassName() + "(" + getName() + ")::inner(" + #type + ")::" + #name)
-#endif // __dynamic_graph_signal_helper_H__
+#endif // __dynamic_graph_signal_helper_H__
diff --git a/include/dynamic-graph/signal-ptr.h b/include/dynamic-graph/signal-ptr.h
index c5dd7b4..78d1331 100644
--- a/include/dynamic-graph/signal-ptr.h
+++ b/include/dynamic-graph/signal-ptr.h
@@ -25,10 +25,10 @@ namespace dynamicgraph {
///
template <class T, class Time>
class SignalPtr : public virtual Signal<T, Time> {
-public:
+ public:
using SignalBase<Time>::getName;
-protected:
+ protected:
Signal<T, Time> *signalPtr;
bool modeNoThrow;
bool transmitAbstract;
@@ -37,19 +37,22 @@ protected:
inline bool autoref() const { return signalPtr == this; }
-public: /* --- CONSTRUCTORS --- */
+ public: /* --- CONSTRUCTORS --- */
SignalPtr(Signal<T, Time> *ptr, std::string name = "")
- : Signal<T, Time>(name), signalPtr(ptr), modeNoThrow(false),
- transmitAbstract(false), abstractTransmitter(NULL) {}
+ : Signal<T, Time>(name),
+ signalPtr(ptr),
+ modeNoThrow(false),
+ transmitAbstract(false),
+ abstractTransmitter(NULL) {}
virtual ~SignalPtr() { signalPtr = NULL; }
-public:
+ public:
/* --- PLUG-IN OPERATION --- */
- Signal<T, Time> *getPtr(); // throw
- const Signal<T, Time> *getPtr() const; // throw
- SignalBase<Time> *getAbstractPtr(); // throw
- const SignalBase<Time> *getAbstractPtr() const; // throw
+ Signal<T, Time> *getPtr(); // throw
+ const Signal<T, Time> *getPtr() const; // throw
+ SignalBase<Time> *getAbstractPtr(); // throw
+ const SignalBase<Time> *getAbstractPtr() const; // throw
virtual void plug(SignalBase<Time> *ref);
virtual void unplug() { plug(NULL); }
@@ -66,7 +69,7 @@ public:
inline const Signal<T, Time> &operator*() const { return *getPtr(); }
inline operator bool() const { return isPlugged(); }
-public: /* --- INHERITANCE --- */
+ public: /* --- INHERITANCE --- */
virtual bool needUpdate(const Time &t) const;
virtual std::ostream &writeGraph(std::ostream &os) const;
virtual std::ostream &display(std::ostream &os) const;
@@ -90,7 +93,7 @@ public: /* --- INHERITANCE --- */
virtual void checkCompatibility();
-public: /* --- INHERITANCE --- */
+ public: /* --- INHERITANCE --- */
/* SignalPtr could be used as a classical signal, through the normal
* setting functions. The behavior is to plugged the signalPtr on
* the classical mother Signal layer of the object.
@@ -126,7 +129,7 @@ public: /* --- INHERITANCE --- */
std::string next1 = "",
std::string next2 = "") const;
-protected: // Interdiction of the rest of the heritage
+ protected: // Interdiction of the rest of the heritage
using Signal<T, Time>::addDependency;
virtual void addDependency() {}
using Signal<T, Time>::removeDependency;
@@ -134,7 +137,7 @@ protected: // Interdiction of the rest of the heritage
virtual void clearDependencies() {}
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
#include <dynamic-graph/signal-ptr.t.cpp>
-#endif //! DYNAMIC_GRAPH_SIGNAL_PTR_H
+#endif //! DYNAMIC_GRAPH_SIGNAL_PTR_H
diff --git a/include/dynamic-graph/signal-ptr.t.cpp b/include/dynamic-graph/signal-ptr.t.cpp
index 95bf711..ed7a4b3 100644
--- a/include/dynamic-graph/signal-ptr.t.cpp
+++ b/include/dynamic-graph/signal-ptr.t.cpp
@@ -17,10 +17,10 @@ bool SignalPtr<T, Time>::isAbstractPluged() const {
return ((NULL != signalPtr) || (abstractTransmitter));
}
-template <class T, class Time> Signal<T, Time> *SignalPtr<T, Time>::getPtr() {
+template <class T, class Time>
+Signal<T, Time> *SignalPtr<T, Time>::getPtr() {
dgTDEBUGIN(25);
- if (!isPlugged())
- DG_THROW
+ if (!isPlugged()) DG_THROW
ExceptionSignal(ExceptionSignal::NOT_INITIALIZED,
"In SignalPtr: SIN ptr not set.", " (in signal <%s>)",
getName().c_str());
@@ -110,7 +110,8 @@ void SignalPtr<T, Time>::plug(SignalBase<Time> *unknown_ref) {
dgTDEBUGOUT(5);
}
-template <class T, class Time> void SignalPtr<T, Time>::checkCompatibility() {
+template <class T, class Time>
+void SignalPtr<T, Time>::checkCompatibility() {
if (isPlugged() && (!autoref())) {
getPtr()->checkCompatibility();
} else if (isAbstractPluged() && (!autoref())) {
@@ -127,7 +128,8 @@ bool SignalPtr<T, Time>::needUpdate(const Time &t) const {
return Signal<T, Time>::needUpdate(t);
}
-template <class T, class Time> const Time &SignalPtr<T, Time>::getTime() const {
+template <class T, class Time>
+const Time &SignalPtr<T, Time>::getTime() const {
if ((isAbstractPluged()) && (!autoref())) {
return getAbstractPtr()->getTime();
}
@@ -158,7 +160,8 @@ const T &SignalPtr<T, Time>::access(const Time &t) {
}
}
-template <class T, class Time> const T &SignalPtr<T, Time>::accessCopy() const {
+template <class T, class Time>
+const T &SignalPtr<T, Time>::accessCopy() const {
if (modeNoThrow && (!isPlugged()) && Signal<T, Time>::copyInit)
return Signal<T, Time>::accessCopy();
else if (autoref())
@@ -204,10 +207,11 @@ std::ostream &SignalPtr<T, Time>::display(std::ostream &os) const {
}
template <class T, class Time>
-std::ostream &
-SignalPtr<T, Time>::displayDependencies(std::ostream &os, const int depth,
- std::string space, std::string next1,
- std::string next2) const {
+std::ostream &SignalPtr<T, Time>::displayDependencies(std::ostream &os,
+ const int depth,
+ std::string space,
+ std::string next1,
+ std::string next2) const {
dgTDEBUGIN(25);
if ((isAbstractPluged()) && (!autoref())) {
getAbstractPtr()->displayDependencies(
@@ -220,6 +224,6 @@ SignalPtr<T, Time>::displayDependencies(std::ostream &os, const int depth,
return os;
}
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
-#endif //! DYNAMIC_GRAPH_SIGNAL_PTR_T_CPP
+#endif //! DYNAMIC_GRAPH_SIGNAL_PTR_T_CPP
diff --git a/include/dynamic-graph/signal-time-dependent.h b/include/dynamic-graph/signal-time-dependent.h
index 32fe49e..2a6749b 100644
--- a/include/dynamic-graph/signal-time-dependent.h
+++ b/include/dynamic-graph/signal-time-dependent.h
@@ -64,7 +64,7 @@ class SignalTimeDependent : public virtual Signal<T, Time>,
public TimeDependency<Time> {
// TimeDependency<Time> timeDependency;
-public:
+ public:
SignalTimeDependent(std::string name = "");
SignalTimeDependent(const SignalArray_const<Time> &arr,
std::string name = "");
@@ -163,6 +163,6 @@ Time SignalTimeDependent<T, Time>::getPeriodTime() const {
return TimeDependency<Time>::getPeriodTime();
}
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_SIGNAL_TIME_DEPENDENT_H
+#endif //! DYNAMIC_GRAPH_SIGNAL_TIME_DEPENDENT_H
diff --git a/include/dynamic-graph/signal.h b/include/dynamic-graph/signal.h
index 2eabff2..ee11c73 100644
--- a/include/dynamic-graph/signal.h
+++ b/include/dynamic-graph/signal.h
@@ -10,14 +10,13 @@
#ifndef __SIGNAL_HH
#define __SIGNAL_HH
+#include <dynamic-graph/exception-signal.h>
+#include <dynamic-graph/signal-base.h>
+
#include <boost/bind.hpp>
#include <boost/function.hpp>
-
#include <string>
-#include <dynamic-graph/exception-signal.h>
-#include <dynamic-graph/signal-base.h>
-
#ifdef HAVE_LIBBOOST_THREAD
#include <boost/thread.hpp>
#endif
@@ -38,8 +37,9 @@ namespace dynamicgraph {
\li using the function setFunction(boost::function2) that will be called
when the signal's value is accessed.
*/
-template <class T, class Time> class Signal : public SignalBase<Time> {
-protected:
+template <class T, class Time>
+class Signal : public SignalBase<Time> {
+ protected:
enum SignalType { CONSTANT, REFERENCE, REFERENCE_NON_CONST, FUNCTION };
static const SignalType SIGNAL_TYPE_DEFAULT = CONSTANT;
@@ -55,7 +55,7 @@ protected:
bool keepReference;
const static bool KEEP_REFERENCE_DEFAULT = false;
-public:
+ public:
#ifdef HAVE_LIBBOOST_THREAD
typedef boost::try_mutex Mutex;
typedef boost::lock_error MutexError;
@@ -64,14 +64,14 @@ public:
typedef int *MutexError;
#endif
-protected:
+ protected:
Mutex *providerMutex;
using SignalBase<Time>::signalTime;
-public:
+ public:
using SignalBase<Time>::setReady;
-public:
+ public:
/* --- Constructor/destrusctor --- */
Signal(std::string name);
virtual ~Signal() {}
@@ -106,23 +106,23 @@ public:
aClassName = typeid(this).name();
}
-public:
+ public:
/// checkCompatibility is used to get the object contained in the
/// signal. This used to verify if a dynamic cast is possible or not.
virtual void checkCompatibility() { throw Tcopy; }
-private:
+ private:
const T &setTcopy(const T &t);
T &getTwork();
const T &getTwork() const;
const T &switchTcopy();
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
#include <dynamic-graph/signal.t.cpp>
-#endif // #ifndef __SIGNAL_HH
+#endif // #ifndef __SIGNAL_HH
/*
* Local variables:
diff --git a/include/dynamic-graph/signal.t.cpp b/include/dynamic-graph/signal.t.cpp
index 4f0d1a5..5501f0f 100644
--- a/include/dynamic-graph/signal.t.cpp
+++ b/include/dynamic-graph/signal.t.cpp
@@ -12,10 +12,10 @@
#define VP_TEMPLATE_DEBUG_MODE 0
#include <dynamic-graph/debug.h>
-#define __SIGNAL_INIT(name, Tcpy, Tref, TrefNC, mutex) \
- SignalBase<Time>(name), signalType(SIGNAL_TYPE_DEFAULT), Tcopy1(Tcpy), \
- Tcopy2(Tcpy), Tcopy(&Tcopy1), Treference(Tref), \
- TreferenceNonConst(TrefNC), Tfunction(), \
+#define __SIGNAL_INIT(name, Tcpy, Tref, TrefNC, mutex) \
+ SignalBase<Time>(name), signalType(SIGNAL_TYPE_DEFAULT), Tcopy1(Tcpy), \
+ Tcopy2(Tcpy), Tcopy(&Tcopy1), Treference(Tref), \
+ TreferenceNonConst(TrefNC), Tfunction(), \
keepReference(KEEP_REFERENCE_DEFAULT), providerMutex(mutex)
namespace dynamicgraph {
@@ -52,7 +52,8 @@ void Signal<T, Time>::trace(std::ostream &os) const {
/* ------------------------------------------------------------------------ */
-template <class T, class Time> const T &Signal<T, Time>::setTcopy(const T &t) {
+template <class T, class Time>
+const T &Signal<T, Time>::setTcopy(const T &t) {
if (Tcopy == &Tcopy1) {
Tcopy2 = t;
copyInit = true;
@@ -66,21 +67,24 @@ template <class T, class Time> const T &Signal<T, Time>::setTcopy(const T &t) {
}
}
-template <class T, class Time> T &Signal<T, Time>::getTwork() {
+template <class T, class Time>
+T &Signal<T, Time>::getTwork() {
if (Tcopy == &Tcopy1)
return Tcopy2;
else
return Tcopy1;
}
-template <class T, class Time> const T &Signal<T, Time>::getTwork() const {
+template <class T, class Time>
+const T &Signal<T, Time>::getTwork() const {
if (Tcopy == &Tcopy1)
return Tcopy2;
else
return Tcopy1;
}
-template <class T, class Time> const T &Signal<T, Time>::switchTcopy() {
+template <class T, class Time>
+const T &Signal<T, Time>::switchTcopy() {
if (Tcopy == &Tcopy1) {
Tcopy = &Tcopy2;
return Tcopy2;
@@ -90,7 +94,8 @@ template <class T, class Time> const T &Signal<T, Time>::switchTcopy() {
}
}
-template <class T, class Time> void Signal<T, Time>::setConstant(const T &t) {
+template <class T, class Time>
+void Signal<T, Time>::setConstant(const T &t) {
signalType = CONSTANT;
setTcopy(t);
setReady();
@@ -125,62 +130,64 @@ void Signal<T, Time>::setFunction(boost::function2<T &, T &, Time> t,
setReady();
}
-template <class T, class Time> const T &Signal<T, Time>::accessCopy() const {
+template <class T, class Time>
+const T &Signal<T, Time>::accessCopy() const {
return *Tcopy;
}
-template <class T, class Time> const T &Signal<T, Time>::access(const Time &t) {
+template <class T, class Time>
+const T &Signal<T, Time>::access(const Time &t) {
switch (signalType) {
- case REFERENCE:
- case REFERENCE_NON_CONST: {
- if (NULL == providerMutex) {
- copyInit = true;
- signalTime = t;
- return setTcopy(*Treference);
- } else {
- try {
-#ifdef HAVE_LIBBOOST_THREAD
- boost::try_mutex::scoped_try_lock lock(*providerMutex);
-#endif
+ case REFERENCE:
+ case REFERENCE_NON_CONST: {
+ if (NULL == providerMutex) {
copyInit = true;
signalTime = t;
return setTcopy(*Treference);
- } catch (const MutexError &) {
- return accessCopy();
+ } else {
+ try {
+#ifdef HAVE_LIBBOOST_THREAD
+ boost::try_mutex::scoped_try_lock lock(*providerMutex);
+#endif
+ copyInit = true;
+ signalTime = t;
+ return setTcopy(*Treference);
+ } catch (const MutexError &) {
+ return accessCopy();
+ }
}
- }
- break;
- }
+ break;
+ }
- case FUNCTION: {
- if (NULL == providerMutex) {
- signalTime = t;
- Tfunction(getTwork(), t);
- copyInit = true;
- return switchTcopy();
- } else {
- try {
-#ifdef HAVE_LIBBOOST_THREAD
- boost::try_mutex::scoped_try_lock lock(*providerMutex);
-#endif
+ case FUNCTION: {
+ if (NULL == providerMutex) {
signalTime = t;
Tfunction(getTwork(), t);
copyInit = true;
return switchTcopy();
- } catch (const MutexError &) {
- return accessCopy();
+ } else {
+ try {
+#ifdef HAVE_LIBBOOST_THREAD
+ boost::try_mutex::scoped_try_lock lock(*providerMutex);
+#endif
+ signalTime = t;
+ Tfunction(getTwork(), t);
+ copyInit = true;
+ return switchTcopy();
+ } catch (const MutexError &) {
+ return accessCopy();
+ }
}
+ break;
}
- break;
- }
- case CONSTANT:
- default:
- if (this->getReady()) {
- setReady(false);
- this->setTime(t);
- }
- return accessCopy();
+ case CONSTANT:
+ default:
+ if (this->getReady()) {
+ setReady(false);
+ this->setTime(t);
+ }
+ return accessCopy();
};
}
@@ -211,23 +218,23 @@ template <class T, class Time>
std::ostream &Signal<T, Time>::display(std::ostream &os) const {
os << "Sig:" << this->name << " (Type ";
switch (this->signalType) {
- case Signal<T, Time>::CONSTANT:
- os << "Cst";
- break;
- case Signal<T, Time>::REFERENCE:
- os << "Ref";
- break;
- case Signal<T, Time>::REFERENCE_NON_CONST:
- os << "RefNonCst";
- break;
- case Signal<T, Time>::FUNCTION:
- os << "Fun";
- break;
+ case Signal<T, Time>::CONSTANT:
+ os << "Cst";
+ break;
+ case Signal<T, Time>::REFERENCE:
+ os << "Ref";
+ break;
+ case Signal<T, Time>::REFERENCE_NON_CONST:
+ os << "RefNonCst";
+ break;
+ case Signal<T, Time>::FUNCTION:
+ os << "Fun";
+ break;
}
return os << ")";
}
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
#undef __SIGNAL_INIT
-#endif //! DYNAMIC_GRAPH_SIGNAL_T_CPP
+#endif //! DYNAMIC_GRAPH_SIGNAL_T_CPP
diff --git a/include/dynamic-graph/time-dependency.h b/include/dynamic-graph/time-dependency.h
index a3d48f0..cc700c3 100644
--- a/include/dynamic-graph/time-dependency.h
+++ b/include/dynamic-graph/time-dependency.h
@@ -5,23 +5,24 @@
#ifndef DYNAMIC_GRAPH_TIME_DEPENDENCY_H
#define DYNAMIC_GRAPH_TIME_DEPENDENCY_H
-#include <list>
-
-#include <dynamic-graph/fwd.hh>
#include <dynamic-graph/signal-array.h>
#include <dynamic-graph/signal-base.h>
+#include <dynamic-graph/fwd.hh>
+#include <list>
+
namespace dynamicgraph {
/** \brief A helper class for setting and specifying dependencies
between signals.
*/
-template <class Time> class TimeDependency {
-public:
+template <class Time>
+class TimeDependency {
+ public:
enum DependencyType { TIME_DEPENDENT, BOOL_DEPENDENT, ALWAYS_READY };
mutable Time lastAskForUpdate;
-public:
+ public:
SignalBase<Time> &leader;
typedef std::list<const SignalBase<Time> *> Dependencies;
@@ -36,7 +37,7 @@ public:
Time periodTime;
static const Time PERIOD_TIME_DEFAULT = 1;
-public:
+ public:
TimeDependency(SignalBase<Time> *sig,
const DependencyType dep = DEPENDENCY_TYPE_DEFAULT);
TimeDependency(SignalBase<Time> *sig, const SignalArray_const<Time> &arr,
@@ -67,7 +68,7 @@ public:
Time getPeriodTime() const { return periodTime; }
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
#include <dynamic-graph/time-dependency.t.cpp>
-#endif //! DYNAMIC_GRAPH_TIME_DEPENDENCY_H
+#endif //! DYNAMIC_GRAPH_TIME_DEPENDENCY_H
diff --git a/include/dynamic-graph/time-dependency.t.cpp b/include/dynamic-graph/time-dependency.t.cpp
index 5596e26..21e455c 100644
--- a/include/dynamic-graph/time-dependency.t.cpp
+++ b/include/dynamic-graph/time-dependency.t.cpp
@@ -11,8 +11,8 @@
#define VP_TEMPLATE_DEBUG_MODE 0
#include <dynamic-graph/debug.h>
-#define __TIME_DEPENDENCY_INIT(sig, dep) \
- leader(*sig), dependencies(), updateFromAllChildren(ALL_READY_DEFAULT), \
+#define __TIME_DEPENDENCY_INIT(sig, dep) \
+ leader(*sig), dependencies(), updateFromAllChildren(ALL_READY_DEFAULT), \
dependencyType(dep), periodTime(PERIOD_TIME_DEFAULT)
namespace dynamicgraph {
@@ -49,7 +49,8 @@ void TimeDependency<Time>::removeDependency(const SignalBase<Time> &sig) {
dependencies.remove(&sig);
}
-template <class Time> void TimeDependency<Time>::clearDependency() {
+template <class Time>
+void TimeDependency<Time>::clearDependency() {
dependencies.clear();
}
@@ -68,19 +69,19 @@ bool TimeDependency<Time>::needUpdate(const Time &t1) const {
}
switch (dependencyType) {
- case ALWAYS_READY: {
- dgTDEBUGOUT(15);
- return true;
- }
- case BOOL_DEPENDENT:
- break;
- case TIME_DEPENDENT: {
- if (t1 < leader.getTime() + periodTime) {
+ case ALWAYS_READY: {
dgTDEBUGOUT(15);
- return false;
+ return true;
+ }
+ case BOOL_DEPENDENT:
+ break;
+ case TIME_DEPENDENT: {
+ if (t1 < leader.getTime() + periodTime) {
+ dgTDEBUGOUT(15);
+ return false;
+ }
+ break;
}
- break;
- }
};
bool res = updateFromAllChildren;
@@ -117,24 +118,23 @@ std::ostream &TimeDependency<Time>::writeGraph(std::ostream &os) const {
}
template <class Time>
-std::ostream &
-TimeDependency<Time>::displayDependencies(std::ostream &os, const int depth,
- std::string space, std::string next1,
- std::string next2) const {
+std::ostream &TimeDependency<Time>::displayDependencies(
+ std::ostream &os, const int depth, std::string space, std::string next1,
+ std::string next2) const {
leader.SignalBase<Time>::displayDependencies(os, depth, space, next1, next2)
<< " (";
switch (dependencyType) {
- case ALWAYS_READY:
- os << "A";
- break;
- case BOOL_DEPENDENT:
- os << "ready=" << ((leader.getReady()) ? "TRUE" : "FALSE");
- break;
- case TIME_DEPENDENT:
- os << "t=" << leader.getTime() << " (/" << periodTime << ") ";
- break;
+ case ALWAYS_READY:
+ os << "A";
+ break;
+ case BOOL_DEPENDENT:
+ os << "ready=" << ((leader.getReady()) ? "TRUE" : "FALSE");
+ break;
+ case TIME_DEPENDENT:
+ os << "t=" << leader.getTime() << " (/" << periodTime << ") ";
+ break;
};
- os << ")"; //<<std::endl;
+ os << ")"; //<<std::endl;
{
const typename Dependencies::const_iterator itend = dependencies.end();
for (typename Dependencies::const_iterator it = dependencies.begin();
@@ -159,7 +159,7 @@ TimeDependency<Time>::displayDependencies(std::ostream &os, const int depth,
return os;
}
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
#undef __TIME_DEPENDENCY_INIT
-#endif //! DYNAMIC_GRAPH_TIME_DEPENDENCY_T_CPP
+#endif //! DYNAMIC_GRAPH_TIME_DEPENDENCY_T_CPP
diff --git a/include/dynamic-graph/tracer-real-time.h b/include/dynamic-graph/tracer-real-time.h
index 1dcf02e..86816ad 100644
--- a/include/dynamic-graph/tracer-real-time.h
+++ b/include/dynamic-graph/tracer-real-time.h
@@ -5,25 +5,25 @@
#ifndef DYNAMIC_GRAPH_TRACER_REAL_TIME_H
#define DYNAMIC_GRAPH_TRACER_REAL_TIME_H
-#include <sstream>
+#include <dynamic-graph/tracer.h>
#include <dynamic-graph/config-tracer-real-time.hh>
#include <dynamic-graph/fwd.hh>
-#include <dynamic-graph/tracer.h>
+#include <sstream>
namespace dynamicgraph {
/// \ingroup plugin
///
/// \brief Stream for the tracer real-time.
class DG_TRACERREALTIME_DLLAPI OutStringStream : public std::ostringstream {
-public:
+ public:
char *buffer;
std::streamsize index;
std::streamsize bufferSize;
bool full;
std::string givenname;
-public:
+ public:
OutStringStream();
~OutStringStream();
@@ -39,7 +39,7 @@ public:
class DG_TRACERREALTIME_DLLAPI TracerRealTime : public Tracer {
DYNAMIC_GRAPH_ENTITY_DECL();
-public:
+ public:
TracerRealTime(const std::string &n);
virtual ~TracerRealTime() {}
@@ -47,8 +47,8 @@ public:
virtual void trace();
void display(std::ostream &os) const;
- DG_TRACERREALTIME_DLLAPI friend std::ostream &
- operator<<(std::ostream &os, const TracerRealTime &t);
+ DG_TRACERREALTIME_DLLAPI friend std::ostream &operator<<(
+ std::ostream &os, const TracerRealTime &t);
void emptyBuffers();
@@ -56,18 +56,18 @@ public:
const int &getBufferSize() { return bufferSize; }
-protected:
+ protected:
virtual void openFile(const SignalBase<int> &sig,
const std::string &filename);
virtual void recordSignal(std::ostream &os, const SignalBase<int> &sig);
typedef std::list<std::ofstream *> HardFileList;
- static const int BUFFER_SIZE_DEFAULT = 1048576; // 1Mo
+ static const int BUFFER_SIZE_DEFAULT = 1048576; // 1Mo
int bufferSize;
HardFileList hardFiles;
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_TRACER_REAL_TIME_H
+#endif //! DYNAMIC_GRAPH_TRACER_REAL_TIME_H
diff --git a/include/dynamic-graph/tracer.h b/include/dynamic-graph/tracer.h
index 3fc7bc9..d014318 100644
--- a/include/dynamic-graph/tracer.h
+++ b/include/dynamic-graph/tracer.h
@@ -5,18 +5,17 @@
#ifndef DYNAMIC_GRAPH_TRACER_H
#define DYNAMIC_GRAPH_TRACER_H
-#include <boost/function.hpp>
-#include <list>
-#include <mutex>
-#include <string>
-
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-traces.h>
#include <dynamic-graph/signal-base.h>
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/time-dependency.h>
+#include <boost/function.hpp>
#include <dynamic-graph/config-tracer.hh>
+#include <list>
+#include <mutex>
+#include <string>
namespace dynamicgraph {
/// \ingroup plugin
@@ -25,12 +24,12 @@ namespace dynamicgraph {
class DG_TRACER_DLLAPI Tracer : public Entity {
DYNAMIC_GRAPH_ENTITY_DECL();
-protected:
+ protected:
typedef std::list<const SignalBase<int> *> SignalList;
SignalList toTraceSignals;
std::mutex files_mtx;
-public:
+ public:
enum TraceStyle {
WHEN_SAID
/// Record, then trace to file only when said to.
@@ -56,7 +55,7 @@ public:
bool play;
int timeStart;
-public:
+ public:
Tracer(const std::string n);
virtual ~Tracer() { closeFiles(); }
@@ -70,11 +69,11 @@ public:
const std::string &suffix);
virtual void closeFiles();
-protected:
+ protected:
virtual void openFile(const SignalBase<int> &sig,
const std::string &filename);
-public:
+ public:
void setTraceStyle(const TraceStyle &style) { traceStyle = style; }
TraceStyle getTraceStyle() { return traceStyle; }
@@ -89,7 +88,7 @@ public:
void start() { play = true; }
void stop() { play = false; }
-public:
+ public:
// SignalTrigerer<int> triger;
SignalTimeDependent<int, int> triger;
@@ -101,6 +100,6 @@ public:
void display(std::ostream &os) const;
};
-} // end of namespace dynamicgraph
+} // end of namespace dynamicgraph
-#endif //! DYNAMIC_GRAPH_TRACER_H
+#endif //! DYNAMIC_GRAPH_TRACER_H
diff --git a/include/dynamic-graph/value.h b/include/dynamic-graph/value.h
index c10ceec..cbd5dd1 100644
--- a/include/dynamic-graph/value.h
+++ b/include/dynamic-graph/value.h
@@ -7,20 +7,22 @@
#ifndef DYNAMIC_GRAPH_VALUE_H
#define DYNAMIC_GRAPH_VALUE_H
-#include "dynamic-graph/dynamic-graph-api.h"
-#include <cassert>
#include <dynamic-graph/linear-algebra.h>
+
+#include <cassert>
#include <string>
#include <typeinfo>
#include <vector>
+#include "dynamic-graph/dynamic-graph-api.h"
+
namespace dynamicgraph {
namespace command {
class Value;
typedef std::vector<Value> Values;
class DYNAMIC_GRAPH_DLLAPI EitherType {
-public:
+ public:
EitherType(const Value &value);
~EitherType();
operator bool() const;
@@ -34,7 +36,7 @@ public:
operator Eigen::Matrix4d() const;
operator Values() const;
-private:
+ private:
const Value *value_;
};
@@ -44,7 +46,7 @@ private:
*/
class DYNAMIC_GRAPH_DLLAPI Value {
-public:
+ public:
enum Type {
NONE,
BOOL,
@@ -101,7 +103,7 @@ public:
DYNAMIC_GRAPH_DLLAPI friend std::ostream &operator<<(std::ostream &os,
const Value &value);
-public:
+ public:
friend class EitherType;
bool boolValue() const;
unsigned unsignedValue() const;
@@ -122,10 +124,11 @@ public:
// Note: to ensure the WIN32 compatibility, it is necessary to export
// the template specialization. Also, it is forbidden to do the template
// specialization declaration in the header file, for the same reason.
-template <typename T> struct DYNAMIC_GRAPH_DLLAPI ValueHelper {
+template <typename T>
+struct DYNAMIC_GRAPH_DLLAPI ValueHelper {
static const Value::Type TypeID;
};
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
-#endif // DYNAMIC_GRAPH_VALUE_H
+#endif // DYNAMIC_GRAPH_VALUE_H
diff --git a/src/command/command.cpp b/src/command/command.cpp
index 3b80526..213ea81 100644
--- a/src/command/command.cpp
+++ b/src/command/command.cpp
@@ -5,9 +5,11 @@
//
#include "dynamic-graph/command.h"
-#include "dynamic-graph/exception-abstract.h"
+
#include <sstream>
+#include "dynamic-graph/exception-abstract.h"
+
namespace dynamicgraph {
namespace command {
@@ -51,5 +53,5 @@ Value Command::execute() { return doExecute(); }
Entity &Command::owner() { return owner_; }
std::string Command::getDocstring() const { return docstring_; }
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
diff --git a/src/command/value.cpp b/src/command/value.cpp
index 8455a91..8ca36ce 100644
--- a/src/command/value.cpp
+++ b/src/command/value.cpp
@@ -5,6 +5,7 @@
//
#include "dynamic-graph/value.h"
+
#include "dynamic-graph/exception-abstract.h"
namespace dynamicgraph {
@@ -33,37 +34,37 @@ EitherType::operator Values() const { return value_->valuesValue(); }
void Value::deleteValue() {
switch (type_) {
- case BOOL:
- delete (const bool *)value_;
- break;
- case UNSIGNED:
- delete (const unsigned *)value_;
- break;
- case INT:
- delete (const int *)value_;
- break;
- case FLOAT:
- delete (const float *)value_;
- break;
- case DOUBLE:
- delete (const double *)value_;
- break;
- case STRING:
- delete (const std::string *)value_;
- break;
- case VECTOR:
- delete (const Vector *)value_;
- break;
- case MATRIX:
- delete (const Eigen::MatrixXd *)value_;
- break;
- case MATRIX4D:
- delete (const Eigen::Matrix4d *)value_;
- break;
- case VALUES:
- delete (const Values *)value_;
- break;
- default:;
+ case BOOL:
+ delete (const bool *)value_;
+ break;
+ case UNSIGNED:
+ delete (const unsigned *)value_;
+ break;
+ case INT:
+ delete (const int *)value_;
+ break;
+ case FLOAT:
+ delete (const float *)value_;
+ break;
+ case DOUBLE:
+ delete (const double *)value_;
+ break;
+ case STRING:
+ delete (const std::string *)value_;
+ break;
+ case VECTOR:
+ delete (const Vector *)value_;
+ break;
+ case MATRIX:
+ delete (const Eigen::MatrixXd *)value_;
+ break;
+ case MATRIX4D:
+ delete (const Eigen::Matrix4d *)value_;
+ break;
+ case VALUES:
+ delete (const Values *)value_;
+ break;
+ default:;
}
}
@@ -90,42 +91,41 @@ Value::Value(const Value &value)
void *copyValue(const Value &value) {
void *copy;
switch (value.type()) {
-
- case Value::NONE:
- copy = NULL;
- break;
- case Value::BOOL:
- copy = new bool(value.boolValue());
- break;
- case Value::UNSIGNED:
- copy = new unsigned(value.unsignedValue());
- break;
- case Value::INT:
- copy = new int(value.intValue());
- break;
- case Value::FLOAT:
- copy = new float(value.floatValue());
- break;
- case Value::DOUBLE:
- copy = new double(value.doubleValue());
- break;
- case Value::STRING:
- copy = new std::string(value.stringValue());
- break;
- case Value::VECTOR:
- copy = new Vector(value.vectorValue());
- break;
- case Value::MATRIX:
- copy = new Eigen::MatrixXd(value.matrixXdValue());
- break;
- case Value::MATRIX4D:
- copy = new Eigen::Matrix4d(value.matrix4dValue());
- break;
- case Value::VALUES:
- copy = new Values(value.valuesValue());
- break;
- default:
- abort();
+ case Value::NONE:
+ copy = NULL;
+ break;
+ case Value::BOOL:
+ copy = new bool(value.boolValue());
+ break;
+ case Value::UNSIGNED:
+ copy = new unsigned(value.unsignedValue());
+ break;
+ case Value::INT:
+ copy = new int(value.intValue());
+ break;
+ case Value::FLOAT:
+ copy = new float(value.floatValue());
+ break;
+ case Value::DOUBLE:
+ copy = new double(value.doubleValue());
+ break;
+ case Value::STRING:
+ copy = new std::string(value.stringValue());
+ break;
+ case Value::VECTOR:
+ copy = new Vector(value.vectorValue());
+ break;
+ case Value::MATRIX:
+ copy = new Eigen::MatrixXd(value.matrixXdValue());
+ break;
+ case Value::MATRIX4D:
+ copy = new Eigen::Matrix4d(value.matrix4dValue());
+ break;
+ case Value::VALUES:
+ copy = new Values(value.valuesValue());
+ break;
+ default:
+ abort();
}
return copy;
}
@@ -134,8 +134,7 @@ Value::Value() : type_(NONE), value_(NULL) {}
Value Value::operator=(const Value &value) {
if (&value != this) {
- if (value_ != 0x0)
- deleteValue();
+ if (value_ != 0x0) deleteValue();
type_ = value.type_;
void **ptValue = const_cast<void **>(&value_);
*ptValue = copyValue(value);
@@ -144,33 +143,32 @@ Value Value::operator=(const Value &value) {
}
bool Value::operator==(const Value &other) const {
- if (type_ != other.type_)
- return false;
+ if (type_ != other.type_) return false;
switch (type_) {
- case Value::BOOL:
- return boolValue() == other.boolValue();
- case Value::UNSIGNED:
- return unsignedValue() == other.unsignedValue();
- case Value::INT:
- return intValue() == other.intValue();
- case Value::DOUBLE:
- return doubleValue() == other.doubleValue();
- case Value::FLOAT:
- return floatValue() == other.floatValue();
- case Value::STRING:
- return stringValue() == other.stringValue();
- case Value::VECTOR:
- return vectorValue() == other.vectorValue();
- case Value::MATRIX:
- return matrixXdValue() == other.matrixXdValue();
- case Value::MATRIX4D:
- return matrix4dValue() == other.matrix4dValue();
- case Value::VALUES:
- return constValuesValue() == other.constValuesValue();
- case Value::NONE:
- break;
- default:
- break;
+ case Value::BOOL:
+ return boolValue() == other.boolValue();
+ case Value::UNSIGNED:
+ return unsignedValue() == other.unsignedValue();
+ case Value::INT:
+ return intValue() == other.intValue();
+ case Value::DOUBLE:
+ return doubleValue() == other.doubleValue();
+ case Value::FLOAT:
+ return floatValue() == other.floatValue();
+ case Value::STRING:
+ return stringValue() == other.stringValue();
+ case Value::VECTOR:
+ return vectorValue() == other.vectorValue();
+ case Value::MATRIX:
+ return matrixXdValue() == other.matrixXdValue();
+ case Value::MATRIX4D:
+ return matrix4dValue() == other.matrix4dValue();
+ case Value::VALUES:
+ return constValuesValue() == other.constValuesValue();
+ case Value::NONE:
+ break;
+ default:
+ break;
}
return false;
}
@@ -180,21 +178,18 @@ const EitherType Value::value() const { return EitherType(*this); }
Value::Type Value::type() const { return type_; }
bool Value::boolValue() const {
- if (type_ == BOOL)
- return *((const bool *)value_);
+ if (type_ == BOOL) return *((const bool *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an bool");
}
unsigned Value::unsignedValue() const {
- if (type_ == UNSIGNED)
- return *((const unsigned *)value_);
+ if (type_ == UNSIGNED) return *((const unsigned *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS,
"value is not an unsigned int");
}
int Value::intValue() const {
- if (type_ == INT)
- return *((const int *)value_);
+ if (type_ == INT) return *((const int *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an int int");
}
@@ -215,127 +210,129 @@ double Value::doubleValue() const {
}
std::string Value::stringValue() const {
- if (type_ == STRING)
- return *((const std::string *)value_);
+ if (type_ == STRING) return *((const std::string *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an string");
}
Vector Value::vectorValue() const {
- if (type_ == VECTOR)
- return *((const Vector *)value_);
+ if (type_ == VECTOR) return *((const Vector *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an vector");
}
Eigen::MatrixXd Value::matrixXdValue() const {
- if (type_ == MATRIX)
- return *((const Eigen::MatrixXd *)value_);
+ if (type_ == MATRIX) return *((const Eigen::MatrixXd *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS,
"value is not a Eigen matrixXd");
}
Eigen::Matrix4d Value::matrix4dValue() const {
- if (type_ == MATRIX4D)
- return *((const Eigen::Matrix4d *)value_);
+ if (type_ == MATRIX4D) return *((const Eigen::Matrix4d *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS,
"value is not a Eigen matrix4d");
}
Values Value::valuesValue() const {
- if (type_ == VALUES)
- return *((const Values *)value_);
+ if (type_ == VALUES) return *((const Values *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS,
"value is not a vector of Value");
}
const Values &Value::constValuesValue() const {
- if (type_ == VALUES)
- return *((const Values *)value_);
+ if (type_ == VALUES) return *((const Values *)value_);
throw ExceptionAbstract(ExceptionAbstract::TOOLS,
"value is not a vector of Value");
}
std::string Value::typeName(Type type) {
switch (type) {
- case BOOL:
- return std::string("bool");
- case UNSIGNED:
- return std::string("unsigned int");
- case INT:
- return std::string("int");
- case FLOAT:
- return std::string("float");
- case DOUBLE:
- return std::string("double");
- case STRING:
- return std::string("string");
- case VECTOR:
- return std::string("vector");
- case MATRIX:
- return std::string("matrixXd");
- case MATRIX4D:
- return std::string("matrix4d");
- case VALUES:
- return std::string("values");
- default:
- return std::string("unknown");
+ case BOOL:
+ return std::string("bool");
+ case UNSIGNED:
+ return std::string("unsigned int");
+ case INT:
+ return std::string("int");
+ case FLOAT:
+ return std::string("float");
+ case DOUBLE:
+ return std::string("double");
+ case STRING:
+ return std::string("string");
+ case VECTOR:
+ return std::string("vector");
+ case MATRIX:
+ return std::string("matrixXd");
+ case MATRIX4D:
+ return std::string("matrix4d");
+ case VALUES:
+ return std::string("values");
+ default:
+ return std::string("unknown");
}
}
std::ostream &operator<<(std::ostream &os, const Value &value) {
os << "Type=" << Value::typeName(value.type_) << ", value=";
switch (value.type_) {
- case Value::BOOL:
- os << value.boolValue();
- break;
- case Value::UNSIGNED:
- os << value.unsignedValue();
- break;
- case Value::INT:
- os << value.intValue();
- break;
- case Value::DOUBLE:
- os << value.doubleValue();
- break;
- case Value::FLOAT:
- os << value.floatValue();
- break;
- case Value::STRING:
- os << value.stringValue();
- break;
- case Value::VECTOR:
- os << value.vectorValue();
- break;
- case Value::MATRIX:
- os << value.matrixXdValue();
- break;
- case Value::MATRIX4D:
- os << value.matrix4dValue();
- break;
- case Value::VALUES: {
- const std::vector<Value> &vals = value.constValuesValue();
- os << "[ ";
- for (std::size_t i = 0; i < vals.size(); ++i)
- os << "Value(" << vals[i] << "), ";
- os << "]";
- } break;
- default:
- return os;
+ case Value::BOOL:
+ os << value.boolValue();
+ break;
+ case Value::UNSIGNED:
+ os << value.unsignedValue();
+ break;
+ case Value::INT:
+ os << value.intValue();
+ break;
+ case Value::DOUBLE:
+ os << value.doubleValue();
+ break;
+ case Value::FLOAT:
+ os << value.floatValue();
+ break;
+ case Value::STRING:
+ os << value.stringValue();
+ break;
+ case Value::VECTOR:
+ os << value.vectorValue();
+ break;
+ case Value::MATRIX:
+ os << value.matrixXdValue();
+ break;
+ case Value::MATRIX4D:
+ os << value.matrix4dValue();
+ break;
+ case Value::VALUES: {
+ const std::vector<Value> &vals = value.constValuesValue();
+ os << "[ ";
+ for (std::size_t i = 0; i < vals.size(); ++i)
+ os << "Value(" << vals[i] << "), ";
+ os << "]";
+ } break;
+ default:
+ return os;
}
return os;
}
-template <> const Value::Type ValueHelper<bool>::TypeID = Value::BOOL;
-template <> const Value::Type ValueHelper<unsigned>::TypeID = Value::UNSIGNED;
-template <> const Value::Type ValueHelper<int>::TypeID = Value::INT;
-template <> const Value::Type ValueHelper<float>::TypeID = Value::FLOAT;
-template <> const Value::Type ValueHelper<double>::TypeID = Value::DOUBLE;
-template <> const Value::Type ValueHelper<std::string>::TypeID = Value::STRING;
-template <> const Value::Type ValueHelper<Vector>::TypeID = Value::VECTOR;
+template <>
+const Value::Type ValueHelper<bool>::TypeID = Value::BOOL;
+template <>
+const Value::Type ValueHelper<unsigned>::TypeID = Value::UNSIGNED;
+template <>
+const Value::Type ValueHelper<int>::TypeID = Value::INT;
+template <>
+const Value::Type ValueHelper<float>::TypeID = Value::FLOAT;
+template <>
+const Value::Type ValueHelper<double>::TypeID = Value::DOUBLE;
+template <>
+const Value::Type ValueHelper<std::string>::TypeID = Value::STRING;
+template <>
+const Value::Type ValueHelper<Vector>::TypeID = Value::VECTOR;
template <>
const Value::Type ValueHelper<Eigen::MatrixXd>::TypeID = Value::MATRIX;
template <>
const Value::Type ValueHelper<Eigen::Matrix4d>::TypeID = Value::MATRIX4D;
-template <> const Value::Type ValueHelper<Values>::TypeID = Value::VALUES;
+template <>
+const Value::Type ValueHelper<Values>::TypeID = Value::VALUES;
-} // namespace command
-} // namespace dynamicgraph
+} // namespace command
+} // namespace dynamicgraph
diff --git a/src/debug/debug.cpp b/src/debug/debug.cpp
index 7734c38..91a6100 100644
--- a/src/debug/debug.cpp
+++ b/src/debug/debug.cpp
@@ -8,6 +8,7 @@
*/
#include <dynamic-graph/debug.h>
+
#include <fstream>
#include <ios>
@@ -32,7 +33,7 @@ std::ofstream dg_debugfile("/tmp/dynamic-graph-traces.txt",
#else
std::ofstream dg_debugfile;
class dgDebug_init {
-public:
+ public:
dgDebug_init() { dg_debugfile.setstate(std::ios::failbit); }
};
dgDebug_init dgDebug_initialisator;
@@ -42,11 +43,10 @@ dgDebug_init dgDebug_initialisator;
namespace dynamicgraph {
DebugTrace dgDEBUGFLOW(dg_debugfile);
DebugTrace dgERRORFLOW(dg_debugfile);
-} // namespace dynamicgraph
+} // namespace dynamicgraph
void DebugTrace::openFile(const char *filename) {
- if (dg_debugfile.good() && dg_debugfile.is_open())
- dg_debugfile.close();
+ if (dg_debugfile.good() && dg_debugfile.is_open()) dg_debugfile.close();
dg_debugfile.clear();
dg_debugfile.open(filename, std::ios::trunc & std::ios::out);
}
diff --git a/src/debug/logger.cpp b/src/debug/logger.cpp
index c132f26..9b0714b 100644
--- a/src/debug/logger.cpp
+++ b/src/debug/logger.cpp
@@ -13,17 +13,18 @@
#define ENABLE_RT_LOG
#include <dynamic-graph/logger.h>
-#include <iomanip> // std::setprecision
-#include <iostream>
-#include <sstream>
+#include <dynamic-graph/real-time-logger.h>
#include <stdio.h>
-#include <dynamic-graph/real-time-logger.h>
+#include <iomanip> // std::setprecision
+#include <iostream>
+#include <sstream>
namespace dynamicgraph {
Logger::Logger(double timeSample, double streamPrintPeriod)
- : m_timeSample(timeSample), m_streamPrintPeriod(streamPrintPeriod),
+ : m_timeSample(timeSample),
+ m_streamPrintPeriod(streamPrintPeriod),
m_printCountdown(0.0) {
m_lv = VERBOSITY_ERROR;
}
@@ -34,8 +35,7 @@ void Logger::setVerbosity(LoggerVerbosity lv) { m_lv = lv; }
LoggerVerbosity Logger::getVerbosity() { return m_lv; }
void Logger::countdown() {
- if (m_printCountdown < 0.0)
- m_printCountdown = m_streamPrintPeriod;
+ if (m_printCountdown < 0.0) m_printCountdown = m_streamPrintPeriod;
m_printCountdown -= m_timeSample;
}
@@ -51,15 +51,13 @@ void Logger::sendMsg(std::string msg, MsgType type, const std::string &file,
}
bool Logger::setTimeSample(double t) {
- if (t <= 0.0)
- return false;
+ if (t <= 0.0) return false;
m_timeSample = t;
return true;
}
bool Logger::setStreamPrintPeriod(double s) {
- if (s <= 0.0)
- return false;
+ if (s <= 0.0) return false;
m_streamPrintPeriod = s;
return true;
}
@@ -79,9 +77,9 @@ bool Logger::checkStreamPeriod(const std::string &lineId) {
counter -= m_timeSample;
if (counter > 0.0) {
return false;
- } else // otherwise reset counter and print
+ } else // otherwise reset counter and print
counter = m_streamPrintPeriod;
return true;
}
-} // namespace dynamicgraph
+} // namespace dynamicgraph
diff --git a/src/debug/real-time-logger.cpp b/src/debug/real-time-logger.cpp
index 8f18971..98f9249 100644
--- a/src/debug/real-time-logger.cpp
+++ b/src/debug/real-time-logger.cpp
@@ -13,21 +13,21 @@
namespace dynamicgraph {
RealTimeLogger::RealTimeLogger(const std::size_t &bufferSize)
- : buffer_(bufferSize, NULL), frontIdx_(0), backIdx_(0), oss_(NULL),
+ : buffer_(bufferSize, NULL),
+ frontIdx_(0),
+ backIdx_(0),
+ oss_(NULL),
nbDiscarded_(0) {
- for (std::size_t i = 0; i < buffer_.size(); ++i)
- buffer_[i] = new Data;
+ for (std::size_t i = 0; i < buffer_.size(); ++i) buffer_[i] = new Data;
}
RealTimeLogger::~RealTimeLogger() {
// Check that we are not spinning...
- for (std::size_t i = 0; i < buffer_.size(); ++i)
- delete buffer_[i];
+ for (std::size_t i = 0; i < buffer_.size(); ++i) delete buffer_[i];
}
bool RealTimeLogger::spinOnce() {
- if (empty())
- return false;
+ if (empty()) return false;
Data *data = buffer_[frontIdx_];
frontIdx_ = (frontIdx_ + 1) % buffer_.size();
std::string str = data->buf.str();
@@ -67,8 +67,11 @@ struct RealTimeLogger::thread {
boost::thread t_;
explicit thread(RealTimeLogger *logger)
- : requestShutdown_(false), threadPolicy_(SCHED_OTHER), threadPriority_(0),
- changedThreadParams(true), t_(&thread::spin, this, logger) {}
+ : requestShutdown_(false),
+ threadPolicy_(SCHED_OTHER),
+ threadPriority_(0),
+ changedThreadParams(true),
+ t_(&thread::spin, this, logger) {}
// void setThreadPolicy(int policy) {
// threadPolicy_ = policy;
@@ -107,8 +110,7 @@ struct RealTimeLogger::thread {
// Do a pause
if (!logger->spinOnce())
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
- if (changedThreadParams)
- changeThreadParams();
+ if (changedThreadParams) changeThreadParams();
}
}
};
@@ -125,11 +127,10 @@ RealTimeLogger &RealTimeLogger::instance() {
}
void RealTimeLogger::destroy() {
- if (instance_ == NULL)
- return;
+ if (instance_ == NULL) return;
thread_->requestShutdown_ = true;
thread_->t_.join();
delete instance_;
delete thread_;
}
-} // namespace dynamicgraph
+} // namespace dynamicgraph
diff --git a/src/dgraph/entity.cpp b/src/dgraph/entity.cpp
index e71eae1..4a1944d 100644
--- a/src/dgraph/entity.cpp
+++ b/src/dgraph/entity.cpp
@@ -14,9 +14,10 @@
#include <dynamic-graph/pool.h>
/*! System includes */
-#include <sstream>
#include <stdlib.h>
+#include <sstream>
+
using namespace std;
using namespace dynamicgraph;
using dynamicgraph::command::Command;
@@ -68,7 +69,7 @@ void Entity::signalRegistration(const SignalArray<int> &signals) {
const string &signame(buffer);
SignalMap::iterator sigkey = signalMap.find(signame);
- if (sigkey != signalMap.end()) // key does exist
+ if (sigkey != signalMap.end()) // key does exist
{
dgERRORF("Key %s already exist in the signalMap.", signame.c_str());
if (sigkey->second != &sig) {
@@ -87,7 +88,7 @@ void Entity::signalRegistration(const SignalArray<int> &signals) {
void Entity::signalDeregistration(const std::string &signame) {
SignalMap::iterator sigkey = signalMap.find(signame);
- if (sigkey == signalMap.end()) // key does not exist
+ if (sigkey == signalMap.end()) // key does not exist
{
dgERRORF("Key %s does not exist in the signalMap.", signame.c_str());
throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL,
@@ -105,14 +106,14 @@ std::string Entity::getDocString() const {
return docString;
}
-#define __DG_ENTITY_GET_SIGNAL__(ITER_TYPE) \
- SignalMap::ITER_TYPE sigkey = signalMap.find(signame); \
- if (sigkey == signalMap.end()) /* key does NOT exist */ \
- { \
- throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL, \
- "The requested signal is not registered", ": %s", \
- signame.c_str()); \
- } \
+#define __DG_ENTITY_GET_SIGNAL__(ITER_TYPE) \
+ SignalMap::ITER_TYPE sigkey = signalMap.find(signame); \
+ if (sigkey == signalMap.end()) /* key does NOT exist */ \
+ { \
+ throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL, \
+ "The requested signal is not registered", ": %s", \
+ signame.c_str()); \
+ } \
return *(sigkey->second);
bool Entity::hasSignal(const string &signame) const {
@@ -185,9 +186,9 @@ const std::string &Entity::getCommandList() const {
/// Add a command to Entity
void Entity::addCommand(const std::string &inName, Command *command) {
if (commandMap.count(inName) != 0) {
- DG_THROW ExceptionFactory(ExceptionFactory::OBJECT_CONFLICT,
- "Command " + inName +
- " already registered in Entity.");
+ DG_THROW ExceptionFactory(
+ ExceptionFactory::OBJECT_CONFLICT,
+ "Command " + inName + " already registered in Entity.");
}
std::pair<const std::string, Command *> item(inName, command);
commandMap.insert(item);
@@ -200,9 +201,9 @@ std::map<const std::string, Command *> Entity::getNewStyleCommandMap() {
Command *Entity::getNewStyleCommand(const std::string &commandName) {
if (commandMap.count(commandName) != 1) {
- DG_THROW ExceptionFactory(ExceptionFactory::UNREFERED_FUNCTION,
- "Command <" + commandName +
- "> is not registered in Entity.");
+ DG_THROW ExceptionFactory(
+ ExceptionFactory::UNREFERED_FUNCTION,
+ "Command <" + commandName + "> is not registered in Entity.");
}
return commandMap[commandName];
}
diff --git a/src/dgraph/factory.cpp b/src/dgraph/factory.cpp
index 514ea66..ee7e1b0 100644
--- a/src/dgraph/factory.cpp
+++ b/src/dgraph/factory.cpp
@@ -2,10 +2,11 @@
// JRL, CNRS/AIST.
//
+#include "dynamic-graph/factory.h"
+
#include <boost/foreach.hpp>
#include "dynamic-graph/debug.h"
-#include "dynamic-graph/factory.h"
using namespace std;
using namespace dynamicgraph;
@@ -39,9 +40,10 @@ void FactoryStorage::registerEntity(const std::string &entname,
"Another entity class already defined with the same name. ",
"(while adding entity class <%s> inside the factory).",
entname.c_str());
- dgERRORF("Another entity class already defined with the same name. "
- "(while adding entity class <%s> inside the factory).",
- entname.c_str());
+ dgERRORF(
+ "Another entity class already defined with the same name. "
+ "(while adding entity class <%s> inside the factory).",
+ entname.c_str());
} else {
if (!ent) {
// FIXME: we should have a better error code for that.
@@ -118,4 +120,4 @@ EntityRegisterer::~EntityRegisterer() {
// The global factory.
FactoryStorage *FactoryStorage::instance_ = NULL;
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
diff --git a/src/dgraph/pool.cpp b/src/dgraph/pool.cpp
index ff5d87a..c6a2c01 100644
--- a/src/dgraph/pool.cpp
+++ b/src/dgraph/pool.cpp
@@ -13,13 +13,15 @@
/* --- DYNAMIC-GRAPH --- */
#include "dynamic-graph/pool.h"
-#include "dynamic-graph/debug.h"
-#include "dynamic-graph/entity.h"
+
#include <list>
#include <sstream>
#include <string>
#include <typeinfo>
+#include "dynamic-graph/debug.h"
+#include "dynamic-graph/entity.h"
+
using namespace dynamicgraph;
/* --------------------------------------------------------------------- */
@@ -57,7 +59,7 @@ PoolStorage::~PoolStorage() {
/* --------------------------------------------------------------------- */
void PoolStorage::registerEntity(const std::string &entname, Entity *ent) {
Entities::iterator entkey = entityMap.find(entname);
- if (entkey != entityMap.end()) // key does exist
+ if (entkey != entityMap.end()) // key does exist
{
throw ExceptionFactory(
ExceptionFactory::OBJECT_CONFLICT,
@@ -72,7 +74,7 @@ void PoolStorage::registerEntity(const std::string &entname, Entity *ent) {
void PoolStorage::deregisterEntity(const std::string &entname) {
Entities::iterator entkey = entityMap.find(entname);
- if (entkey == entityMap.end()) // key doesnot exist
+ if (entkey == entityMap.end()) // key doesnot exist
{
throw ExceptionFactory(ExceptionFactory::OBJECT_CONFLICT,
"Entity not defined yet. ", "Entity name is <%s>.",
@@ -207,7 +209,7 @@ static bool objectNameParser(std::istringstream &cmdparse, std::string &objName,
char buffer[SIZE];
cmdparse >> std::ws;
cmdparse.getline(buffer, SIZE, '.');
- if (!cmdparse.good()) // The callback is not an object method
+ if (!cmdparse.good()) // The callback is not an object method
return false;
objName = buffer;
diff --git a/src/exception/exception-abstract.cpp b/src/exception/exception-abstract.cpp
index 2d9089c..b5357c0 100644
--- a/src/exception/exception-abstract.cpp
+++ b/src/exception/exception-abstract.cpp
@@ -2,10 +2,11 @@
// JRL, CNRS/AIST.
//
-#include <cstring>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/exception-abstract.h>
+#include <cstring>
+
namespace dynamicgraph {
const std::string ExceptionAbstract::EXCEPTION_NAME = "Abstract";
@@ -23,8 +24,7 @@ const std::string &ExceptionAbstract::getStringMessage() const {
int ExceptionAbstract::getCode() const { return this->code; }
ExceptionAbstract::Param &ExceptionAbstract::Param::initCopy(const Param &p) {
- if (&p == this)
- return *this;
+ if (&p == this) return *this;
dgDEBUGIN(25);
if (p.pointersSet) {
@@ -53,9 +53,9 @@ std::ostream &operator<<(std::ostream &os, const ExceptionAbstract &error) {
if (error.p.set)
os << "Thrown from " << error.p.file << ": " << error.p.function << " (#"
<< error.p.line << ")" << std::endl;
-#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
return os;
}
-} // end of namespace dynamicgraph.
+} // end of namespace dynamicgraph.
diff --git a/src/exception/exception-factory.cpp b/src/exception/exception-factory.cpp
index f510bca..505a4b0 100644
--- a/src/exception/exception-factory.cpp
+++ b/src/exception/exception-factory.cpp
@@ -7,11 +7,12 @@
*
*/
-#include <cstdio>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/exception-factory.h>
#include <stdarg.h>
+#include <cstdio>
+
using namespace dynamicgraph;
/* --------------------------------------------------------------------- */
diff --git a/src/exception/exception-signal.cpp b/src/exception/exception-signal.cpp
index ee80de7..e9b705b 100644
--- a/src/exception/exception-signal.cpp
+++ b/src/exception/exception-signal.cpp
@@ -7,10 +7,11 @@
*
*/
-#include <cstdio>
#include <dynamic-graph/exception-signal.h>
#include <stdarg.h>
+#include <cstdio>
+
using namespace dynamicgraph;
/* --------------------------------------------------------------------- */
diff --git a/src/exception/exception-traces.cpp b/src/exception/exception-traces.cpp
index 7fdb886..1757df4 100644
--- a/src/exception/exception-traces.cpp
+++ b/src/exception/exception-traces.cpp
@@ -7,10 +7,11 @@
*
*/
-#include <cstdio>
#include <dynamic-graph/exception-traces.h>
#include <stdarg.h>
+#include <cstdio>
+
using namespace dynamicgraph;
/* --------------------------------------------------------------------- */
/* --- CLASS ----------------------------------------------------------- */
diff --git a/src/mt/process-list.cpp b/src/mt/process-list.cpp
index 0c425b0..8158f1f 100644
--- a/src/mt/process-list.cpp
+++ b/src/mt/process-list.cpp
@@ -2,17 +2,24 @@
* Author: O. Stasse, 2019
* See LICENSE file in the root directory of this repository.
*/
+#include <dynamic-graph/process-list.hh>
#include <fstream>
#include <sstream>
#include <string>
-#include <dynamic-graph/process-list.hh>
-
using namespace dynamicgraph::CPU;
CPUData::CPUData()
- : user_mode_time_(0), nice_time_(0), system_time_(0), idle_time_(0),
- iowait_time_(0), irq_time_(0), softirq_time_(0), steal_time_(0),
- guest_time_(0), guest_nice_time_(0), percent_(0.0) {}
+ : user_mode_time_(0),
+ nice_time_(0),
+ system_time_(0),
+ idle_time_(0),
+ iowait_time_(0),
+ irq_time_(0),
+ softirq_time_(0),
+ steal_time_(0),
+ guest_time_(0),
+ guest_nice_time_(0),
+ percent_(0.0) {}
void CPUData::ProcessLine(std::istringstream &aCPULine) {
unsigned long long int luser_mode_time = 0, lnice_time = 0, lsystem_time = 0,
@@ -129,8 +136,7 @@ void System::readProcStat() {
// If we did not initialize
if (!init_) {
// Count the number of CPU.
- if (lcpunb > cpuNb_)
- cpuNb_ = lcpunb;
+ if (lcpunb > cpuNb_) cpuNb_ = lcpunb;
} else
// Otherwise process the line.
ProcessCPULine(lcpunb, anISSLine);
diff --git a/src/traces/tracer-real-time.cpp b/src/traces/tracer-real-time.cpp
index 70c4c12..cf83e9a 100644
--- a/src/traces/tracer-real-time.cpp
+++ b/src/traces/tracer-real-time.cpp
@@ -12,15 +12,15 @@
/* --------------------------------------------------------------------- */
/* DG */
-#include <boost/bind.hpp>
-#include <iomanip>
-
#include <dynamic-graph/all-commands.h>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/pool.h>
#include <dynamic-graph/tracer-real-time.h>
+#include <boost/bind.hpp>
+#include <iomanip>
+
using namespace std;
using namespace dynamicgraph;
@@ -103,7 +103,7 @@ TracerRealTime::TracerRealTime(const std::string &n)
addCommand("setBufferSize",
makeDirectSetter(*this, &bufferSize,
docDirectSetter("bufferSize", "int")));
- } // using namespace command
+ } // using namespace command
dgDEBUGOUT(15);
}
@@ -136,7 +136,7 @@ void TracerRealTime::openFile(const SignalBase<int> &sig,
dgDEBUG(5) << "Creating Outstringstream" << endl;
// std::stringstream * newbuffer = new std::stringstream ();
- OutStringStream *newbuffer = new OutStringStream(); // std::stringstream ();
+ OutStringStream *newbuffer = new OutStringStream(); // std::stringstream ();
newbuffer->resize(bufferSize);
newbuffer->givenname = givenname;
files.push_back(newbuffer);
@@ -187,7 +187,7 @@ void TracerRealTime::trace() {
"");
}
// std::stringstream & file = * dynamic_cast< stringstream* >(os);
- OutStringStream *file = dynamic_cast<OutStringStream *>(os); // segfault
+ OutStringStream *file = dynamic_cast<OutStringStream *>(os); // segfault
if (NULL == file) {
DG_THROW ExceptionTraces(ExceptionTraces::NOT_OPEN,
"The buffer is not open", "");
@@ -269,8 +269,7 @@ void TracerRealTime::display(std::ostream &os) const {
dgDEBUG(35) << "Next" << endl;
const OutStringStream *file = dynamic_cast<OutStringStream *>(*iterFile);
os << " -> " << (*iter)->getName();
- if (file->givenname.length())
- os << " (in " << file->givenname << ")";
+ if (file->givenname.length()) os << " (in " << file->givenname << ")";
os << "\t";
if (file) {
const std::streamsize PRECISION = os.precision();
@@ -292,8 +291,7 @@ void TracerRealTime::display(std::ostream &os) const {
<< (((double)SIZE + 0.0) / (1 << dec)) << unit << "/"
<< std::setprecision(2) << (((double)MSIZE + 0.0) / (1 << dec)) << unit
<< "]\t";
- if (file->full)
- os << "(FULL)";
+ if (file->full) os << "(FULL)";
os.precision(PRECISION);
}
os << endl;
diff --git a/src/traces/tracer.cpp b/src/traces/tracer.cpp
index e43df73..a6c14e1 100644
--- a/src/traces/tracer.cpp
+++ b/src/traces/tracer.cpp
@@ -12,7 +12,6 @@
/* --------------------------------------------------------------------- */
/* DG */
-#include <boost/bind.hpp>
#include <dynamic-graph/all-commands.h>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/factory.h>
@@ -20,6 +19,8 @@
#include <dynamic-graph/tracer.h>
#include <dynamic-graph/value.h>
+#include <boost/bind.hpp>
+
using namespace std;
using namespace dynamicgraph;
using namespace dynamicgraph::command;
@@ -31,9 +32,18 @@ DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(Tracer, "Tracer");
/* --------------------------------------------------------------------- */
Tracer::Tracer(const std::string n)
- : Entity(n), toTraceSignals(), traceStyle(TRACE_STYLE_DEFAULT),
- frequency(1), basename(), suffix(".dat"), rootdir(), namesSet(false),
- files(), names(), play(false), timeStart(0),
+ : Entity(n),
+ toTraceSignals(),
+ traceStyle(TRACE_STYLE_DEFAULT),
+ frequency(1),
+ basename(),
+ suffix(".dat"),
+ rootdir(),
+ namesSet(false),
+ files(),
+ names(),
+ play(false),
+ timeStart(0),
triger(boost::bind(&Tracer::recordTrigger, this, _1, _2), sotNOSIGNAL,
"Tracer(" + n + ")::triger") {
signalRegistration(triger);
@@ -62,8 +72,9 @@ Tracer::Tracer(const std::string n)
doc = docCommandVoid0("Close all the open files.");
addCommand("close", makeCommandVoid0(*this, &Tracer::closeFiles, doc));
- doc = docCommandVoid0("If necessary, dump "
- "(can be done automatically for some traces type).");
+ doc = docCommandVoid0(
+ "If necessary, dump "
+ "(can be done automatically for some traces type).");
addCommand("dump", makeCommandVoid0(*this, &Tracer::trace, doc));
doc = docCommandVoid0("Start the tracing process.");
@@ -78,7 +89,7 @@ Tracer::Tracer(const std::string n)
addCommand("setTimeStart",
makeDirectSetter(*this, &timeStart,
docDirectSetter("timeStart", "int")));
- } // using namespace command
+ } // using namespace command
}
/* --------------------------------------------------------------------- */
@@ -89,8 +100,7 @@ void Tracer::addSignalToTrace(const SignalBase<int> &sig,
const string &filename) {
dgDEBUGIN(15);
// openFile may throw so it should be called first.
- if (namesSet)
- openFile(sig, filename);
+ if (namesSet) openFile(sig, filename);
toTraceSignals.push_back(&sig);
dgDEBUGF(15, "%p", &sig);
names.push_back(filename);
@@ -129,14 +139,12 @@ void Tracer::openFiles(const std::string &rootdir_,
dgDEBUGIN(15);
std::basic_string<char>::size_type n = rootdir_.length();
rootdir = rootdir_;
- if ((0 < n) & ('/' != rootdir[n - 1]))
- rootdir += '/';
+ if ((0 < n) & ('/' != rootdir[n - 1])) rootdir += '/';
basename = basename_;
suffix = suffix_;
- if (files.size())
- closeFiles();
+ if (files.size()) closeFiles();
SignalList::const_iterator iter = toTraceSignals.begin();
NameList::const_iterator iterName = names.begin();
diff --git a/tests/command-test.cpp b/tests/command-test.cpp
index 5764d62..3a5f2a1 100644
--- a/tests/command-test.cpp
+++ b/tests/command-test.cpp
@@ -5,14 +5,16 @@
* See LICENSE file
*
*/
-#include "dynamic-graph/command-bind.h"
-#include "dynamic-graph/factory.h"
-#include "dynamic-graph/pool.h"
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
+
#include <iostream>
#include <sstream>
+#include "dynamic-graph/command-bind.h"
+#include "dynamic-graph/factory.h"
+#include "dynamic-graph/pool.h"
+
#define ENABLE_RT_LOG
#include <dynamic-graph/logger.h>
#include <dynamic-graph/real-time-logger.h>
@@ -32,7 +34,7 @@ using namespace dynamicgraph::command;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
static const std::string CLASS_NAME;
bool test_zero_arg_;
bool test_one_arg_;
@@ -127,7 +129,7 @@ public:
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(command_test) {
dynamicgraph::CustomEntity *ptr_entity =
@@ -142,8 +144,7 @@ BOOST_AUTO_TEST_CASE(command_test) {
std::map<const std::string, Command *>::iterator it_map;
it_map = aCommandMap.find("0_arg");
- if (it_map == aCommandMap.end())
- BOOST_CHECK(false);
+ if (it_map == aCommandMap.end()) BOOST_CHECK(false);
it_map->second->execute();
BOOST_CHECK(entity.test_zero_arg_);
@@ -158,8 +159,7 @@ BOOST_AUTO_TEST_CASE(command_test) {
for (unsigned int i = 0; i < 4; i++) {
it_map = aCommandMap.find(vec_fname[i]);
- if (it_map == aCommandMap.end())
- BOOST_CHECK(false);
+ if (it_map == aCommandMap.end()) BOOST_CHECK(false);
values.push_back(aValue);
it_map->second->setParameterValues(values);
it_map->second->execute();
diff --git a/tests/custom-entity.cpp b/tests/custom-entity.cpp
index 5f129f0..164f293 100644
--- a/tests/custom-entity.cpp
+++ b/tests/custom-entity.cpp
@@ -5,6 +5,7 @@
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/pool.h>
+
#include <sstream>
#define BOOST_TEST_MODULE customEntity
diff --git a/tests/debug-logger-winit.cpp b/tests/debug-logger-winit.cpp
index 26ca806..625c612 100644
--- a/tests/debug-logger-winit.cpp
+++ b/tests/debug-logger-winit.cpp
@@ -9,14 +9,14 @@
#include <sstream>
#define ENABLE_RT_LOG
-#include "dynamic-graph/factory.h"
-#include "dynamic-graph/pool.h"
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
-
#include <dynamic-graph/logger.h>
#include <dynamic-graph/real-time-logger.h>
+#include "dynamic-graph/factory.h"
+#include "dynamic-graph/pool.h"
+
#define BOOST_TEST_MODULE debug - logger
#if BOOST_VERSION >= 105900
@@ -24,16 +24,15 @@
#else
#include <boost/test/output_test_stream.hpp>
#endif
-#include <boost/test/unit_test.hpp>
-
#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/test/unit_test.hpp>
#include <boost/thread/thread.hpp>
using boost::test_tools::output_test_stream;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
static const std::string CLASS_NAME;
virtual const std::string &getClassName() const { return CLASS_NAME; }
explicit CustomEntity(const std::string &n) : Entity(n) {
@@ -63,7 +62,7 @@ public:
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(debug_logger_wrong_initialization) {
dynamicgraph::RealTimeLogger::instance();
diff --git a/tests/debug-logger.cpp b/tests/debug-logger.cpp
index 4c4222b..150112f 100644
--- a/tests/debug-logger.cpp
+++ b/tests/debug-logger.cpp
@@ -5,13 +5,15 @@
* See LICENSE file
*
*/
-#include "dynamic-graph/factory.h"
-#include "dynamic-graph/pool.h"
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
+
#include <iostream>
#include <sstream>
+#include "dynamic-graph/factory.h"
+#include "dynamic-graph/pool.h"
+
#define ENABLE_RT_LOG
#include <dynamic-graph/logger.h>
#include <dynamic-graph/real-time-logger.h>
@@ -29,7 +31,7 @@ using boost::test_tools::output_test_stream;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
static const std::string CLASS_NAME;
virtual const std::string &getClassName() const { return CLASS_NAME; }
explicit CustomEntity(const std::string &n) : Entity(n) {
@@ -122,7 +124,7 @@ public:
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(debug_logger) {
std::ofstream of;
diff --git a/tests/debug-real-time-tracer.cpp b/tests/debug-real-time-tracer.cpp
index e41dc44..ace8683 100644
--- a/tests/debug-real-time-tracer.cpp
+++ b/tests/debug-real-time-tracer.cpp
@@ -4,8 +4,6 @@
*
*/
-#include <iostream>
-
#include <dynamic-graph/command.h>
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
@@ -14,6 +12,8 @@
#include <dynamic-graph/signal-ptr.h>
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/tracer-real-time.h>
+
+#include <iostream>
#define BOOST_TEST_MODULE debug - tracer
#if BOOST_VERSION >= 105900
@@ -53,7 +53,7 @@ struct MyEntity : public dynamicgraph::Entity {
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(MyEntity, "MyEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(test_tracer) {
using namespace dynamicgraph;
diff --git a/tests/debug-trace.cpp b/tests/debug-trace.cpp
index bf3f452..d2cd118 100644
--- a/tests/debug-trace.cpp
+++ b/tests/debug-trace.cpp
@@ -3,13 +3,15 @@
* Olivier Stasse
*
*/
-#include "dynamic-graph/factory.h"
-#include "dynamic-graph/pool.h"
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
+
#include <iostream>
#include <sstream>
+#include "dynamic-graph/factory.h"
+#include "dynamic-graph/pool.h"
+
#define VP_DEBUG 1
#define VP_DEBUG_MODE 50
#define VP_TEMPLATE_DEBUG_MODE 50
@@ -29,7 +31,7 @@ using boost::test_tools::output_test_stream;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
static const std::string CLASS_NAME;
virtual const std::string &getClassName() const { return CLASS_NAME; }
explicit CustomEntity(const std::string &n) : Entity(n) {
@@ -52,7 +54,7 @@ public:
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(testDebugTrace) {
BOOST_CHECK_EQUAL(dynamicgraph::CustomEntity::CLASS_NAME, "CustomEntity");
@@ -86,10 +88,11 @@ BOOST_AUTO_TEST_CASE(testDebugTrace) {
the_debug_file.close();
// Compare with the strings put inside this source file
- std::string str_to_test = "# In {"
- "# In/Out { }"
- "Here is a test"
- "# Out }";
+ std::string str_to_test =
+ "# In {"
+ "# In/Out { }"
+ "Here is a test"
+ "# Out }";
bool two_sub_string_identical;
// Make comparisons.
diff --git a/tests/debug-tracer.cpp b/tests/debug-tracer.cpp
index 2944667..0cd87f7 100644
--- a/tests/debug-tracer.cpp
+++ b/tests/debug-tracer.cpp
@@ -4,8 +4,6 @@
*
*/
-#include <iostream>
-
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/factory.h>
@@ -14,6 +12,8 @@
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/tracer.h>
+#include <iostream>
+
#define BOOST_TEST_MODULE debug - tracer
#if BOOST_VERSION >= 105900
@@ -70,7 +70,7 @@ struct MyEntity : public dynamicgraph::Entity {
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(MyEntity, "MyEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(test_tracer) {
using dynamicgraph::Vector;
diff --git a/tests/entity.cpp b/tests/entity.cpp
index 4406123..3ae1e85 100644
--- a/tests/entity.cpp
+++ b/tests/entity.cpp
@@ -5,8 +5,6 @@
#define ENABLE_RT_LOG
-#include "dynamic-graph/factory.h"
-#include "dynamic-graph/pool.h"
#include <dynamic-graph/command-direct-getter.h>
#include <dynamic-graph/command-direct-setter.h>
#include <dynamic-graph/entity.h>
@@ -14,8 +12,12 @@
#include <dynamic-graph/real-time-logger.h>
#include <dynamic-graph/signal-ptr.h>
#include <dynamic-graph/signal-time-dependent.h>
+
#include <sstream>
+#include "dynamic-graph/factory.h"
+#include "dynamic-graph/pool.h"
+
#define BOOST_TEST_MODULE entity
#if BOOST_VERSION >= 105900
@@ -29,7 +31,7 @@ using boost::test_tools::output_test_stream;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
dynamicgraph::SignalPtr<double, int> m_sigdSIN, m_sigdSIN2;
dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
@@ -69,11 +71,11 @@ public:
return res;
}
-public:
+ public:
double m_value;
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
-} // namespace dynamicgraph
+} // namespace dynamicgraph
BOOST_AUTO_TEST_CASE(constructor) {
namespace dg = dynamicgraph;
diff --git a/tests/exceptions.cpp b/tests/exceptions.cpp
index 7cadbde..f8b778b 100644
--- a/tests/exceptions.cpp
+++ b/tests/exceptions.cpp
@@ -6,9 +6,8 @@
#include <dynamic-graph/exception-signal.h>
#include <dynamic-graph/exception-traces.h>
-#include <sstream>
-
#include <boost/version.hpp>
+#include <sstream>
#if BOOST_VERSION >= 105900
#include <boost/test/tools/output_test_stream.hpp>
@@ -22,7 +21,6 @@ using boost::test_tools::output_test_stream;
using namespace dynamicgraph;
BOOST_AUTO_TEST_CASE(exception_abstract_param) {
-
/// Test param from Exception
/// Default constructor
ExceptionAbstract::Param aParamSimple;
@@ -32,7 +30,6 @@ BOOST_AUTO_TEST_CASE(exception_abstract_param) {
}
BOOST_AUTO_TEST_CASE(exception_abstract) {
-
/// Test exception abstract with a simple message
std::string msg_aea("Test exception abstract");
ExceptionAbstract aEA(10, msg_aea);
@@ -48,7 +45,6 @@ BOOST_AUTO_TEST_CASE(exception_abstract) {
}
BOOST_AUTO_TEST_CASE(exception_traces) {
-
std::string msg_aet("Test exception traces simple");
ExceptionTraces aET(ExceptionTraces::GENERIC, msg_aet);
output_test_stream output;
diff --git a/tests/factory.cpp b/tests/factory.cpp
index d8fc1ff..0f70998 100644
--- a/tests/factory.cpp
+++ b/tests/factory.cpp
@@ -4,6 +4,7 @@
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/factory.h>
+
#include <sstream>
#define BOOST_TEST_MODULE factory
@@ -19,13 +20,13 @@ using boost::test_tools::output_test_stream;
namespace dynamicgraph {
class CustomEntity : public Entity {
-public:
+ public:
static const std::string CLASS_NAME;
virtual const std::string &getClassName() const { return CLASS_NAME; }
explicit CustomEntity(const std::string &n) : Entity(n) {}
};
const std::string CustomEntity::CLASS_NAME = "CustomEntity";
-} // namespace dynamicgraph
+} // namespace dynamicgraph
dynamicgraph::Entity *makeEntity(const std::string &objectName) {
return new dynamicgraph::CustomEntity(objectName);
diff --git a/tests/interpreter-tracer.cpp b/tests/interpreter-tracer.cpp
index a9d7ca6..4d1207d 100644
--- a/tests/interpreter-tracer.cpp
+++ b/tests/interpreter-tracer.cpp
@@ -4,6 +4,7 @@
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/interpreter.h>
#include <dynamic-graph/plugin-loader.h>
+
#include <sstream>
#define BOOST_TEST_MODULE tracer
diff --git a/tests/pool.cpp b/tests/pool.cpp
index 00b96fc..2152c15 100644
--- a/tests/pool.cpp
+++ b/tests/pool.cpp
@@ -7,6 +7,7 @@
#include <dynamic-graph/pool.h>
#include <dynamic-graph/signal-ptr.h>
#include <dynamic-graph/signal-time-dependent.h>
+
#include <iostream>
#include <sstream>
diff --git a/tests/real-time-logger.cpp b/tests/real-time-logger.cpp
index da030de..102ec44 100644
--- a/tests/real-time-logger.cpp
+++ b/tests/real-time-logger.cpp
@@ -18,9 +18,8 @@
#else
#include <boost/test/output_test_stream.hpp>
#endif
-#include <boost/test/unit_test.hpp>
-
#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/test/unit_test.hpp>
#include <boost/thread/thread.hpp>
using namespace dynamicgraph;
@@ -28,8 +27,7 @@ using namespace dynamicgraph;
BOOST_AUTO_TEST_CASE(monothread) {
RealTimeLogger rtl(10);
rtl.addOutputStream(LoggerStreamPtr_t(new LoggerIOStream(std::cout)));
- for (int i = 0; i < 9; ++i)
- rtl.front() << "Call number " << i << '\n';
+ for (int i = 0; i < 9; ++i) rtl.front() << "Call number " << i << '\n';
BOOST_CHECK(rtl.full());
rtl.front() << "This call should not appear in the output" << '\n';
diff --git a/tests/signal-all.cpp b/tests/signal-all.cpp
index f49d1c1..7235dfd 100644
--- a/tests/signal-all.cpp
+++ b/tests/signal-all.cpp
@@ -2,15 +2,14 @@
// Created by corentin on 7/3/19.
//
-#include <boost/foreach.hpp>
-
+#include <assert.h>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/signal-array.h>
#include <dynamic-graph/signal-caster.h>
#include <dynamic-graph/tracer.h>
-#include <assert.h>
+#include <boost/foreach.hpp>
#if BOOST_VERSION >= 105900
#include <boost/test/tools/output_test_stream.hpp>
#else
diff --git a/tests/signal-cast-registerer.cpp b/tests/signal-cast-registerer.cpp
index fca2890..33b5c93 100644
--- a/tests/signal-cast-registerer.cpp
+++ b/tests/signal-cast-registerer.cpp
@@ -1,12 +1,6 @@
// Copyright 2010 Thomas Moulard.
//
-#include <string>
-
-#include <boost/foreach.hpp>
-#include <boost/format.hpp>
-
-#include "signal-cast-register-test.h"
#include <dynamic-graph/debug.h>
#include <dynamic-graph/eigen-io.h>
#include <dynamic-graph/entity.h>
@@ -15,6 +9,11 @@
#include <dynamic-graph/pool.h>
#include <dynamic-graph/signal.h>
+#include <boost/foreach.hpp>
+#include <boost/format.hpp>
+#include <string>
+
+#include "signal-cast-register-test.h"
#include "signal-cast-registerer-libA.hh"
#include "signal-cast-registerer-libB.hh"
diff --git a/tests/signal-ptr.cpp b/tests/signal-ptr.cpp
index fbe4268..2fc5447 100644
--- a/tests/signal-ptr.cpp
+++ b/tests/signal-ptr.cpp
@@ -1,10 +1,6 @@
// Copyright 2010 Thomas Moulard.
//
-#include <string>
-
-#include <boost/foreach.hpp>
-
#include <dynamic-graph/debug.h>
#include <dynamic-graph/entity.h>
#include <dynamic-graph/factory.h>
@@ -13,7 +9,10 @@
#include <dynamic-graph/signal-ptr.h>
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/signal.h>
+
+#include <boost/foreach.hpp>
#include <iostream>
+#include <string>
#if BOOST_VERSION >= 105900
#include <boost/test/tools/output_test_stream.hpp>
@@ -32,8 +31,9 @@ typedef dynamicgraph::SignalTimeDependent<std::string, int> sigString_t;
using namespace dynamicgraph;
using std::cout;
-template <class T> class DummyClass {
-public:
+template <class T>
+class DummyClass {
+ public:
std::string proname;
std::list<sigDouble_t *> inputsig;
std::list<sigString_t *> inputsigV;
@@ -65,17 +65,22 @@ public:
int timedata;
};
-template <> double DummyClass<double>::operator()() {
+template <>
+double DummyClass<double>::operator()() {
res = call * timedata;
return res;
}
-template <> std::string DummyClass<std::string>::operator()() {
+template <>
+std::string DummyClass<std::string>::operator()() {
std::ostringstream oss;
oss << call * timedata;
return oss.str();
}
-template <class T> T DummyClass<T>::operator()() { return this->res; }
+template <class T>
+T DummyClass<T>::operator()() {
+ return this->res;
+}
BOOST_AUTO_TEST_CASE(normal_cst_test) {
SignalPtr<double, int> sigNotPlug(NULL, "sigNotPlug");
diff --git a/tests/signal-time-dependent.cpp b/tests/signal-time-dependent.cpp
index 816820b..6a9ae00 100644
--- a/tests/signal-time-dependent.cpp
+++ b/tests/signal-time-dependent.cpp
@@ -1,11 +1,11 @@
// Copyright 2010 Thomas Moulard.
//
-#include <boost/foreach.hpp>
-#include <iostream>
-
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/signal.h>
+#include <boost/foreach.hpp>
+#include <iostream>
+
#define BOOST_TEST_MODULE signal_time_dependent
#if BOOST_VERSION >= 105900
@@ -20,8 +20,9 @@ using boost::test_tools::output_test_stream;
typedef dynamicgraph::SignalTimeDependent<double, int> sigDouble_t;
typedef dynamicgraph::SignalTimeDependent<std::string, int> sigString_t;
-template <class T> class DummyClass {
-public:
+template <class T>
+class DummyClass {
+ public:
std::string proname;
std::list<sigDouble_t *> inputsig;
std::list<sigString_t *> inputsigV;
@@ -53,17 +54,22 @@ public:
int timedata;
};
-template <> double DummyClass<double>::operator()() {
+template <>
+double DummyClass<double>::operator()() {
res = call * timedata;
return res;
}
-template <> std::string DummyClass<std::string>::operator()() {
+template <>
+std::string DummyClass<std::string>::operator()() {
std::ostringstream oss;
oss << call * timedata;
return oss.str();
}
-template <class T> T DummyClass<T>::operator()() { return this->res; }
+template <class T>
+T DummyClass<T>::operator()() {
+ return this->res;
+}
BOOST_AUTO_TEST_CASE(signaltimedependent) {
DummyClass<double> pro1("pro1"), pro3("pro3"), pro5("pro5");
diff --git a/tests/test-mt.cpp b/tests/test-mt.cpp
index 5d90413..5d44bae 100644
--- a/tests/test-mt.cpp
+++ b/tests/test-mt.cpp
@@ -3,11 +3,12 @@
* Olivier Stasse
*
*/
+#include <unistd.h>
+
#include <dynamic-graph/process-list.hh>
#include <fstream>
#include <iostream>
#include <sstream>
-#include <unistd.h>
#define BOOST_TEST_MODULE debug - trace
diff --git a/tests/value.cpp b/tests/value.cpp
index 17d15dc..6707453 100644
--- a/tests/value.cpp
+++ b/tests/value.cpp
@@ -2,7 +2,9 @@
//
#include "dynamic-graph/value.h"
+
#include <dynamic-graph/exception-factory.h>
+
#include <iostream>
#define BOOST_TEST_MODULE value
@@ -70,8 +72,8 @@ BOOST_AUTO_TEST_CASE(value_exceptions) {
bool res = false;
try {
int aInt(anet);
- aInt++; // silence unused variable warnings to have a stable release in the
- // ros buildfarm
+ aInt++; // silence unused variable warnings to have a stable release in the
+ // ros buildfarm
} catch (const dg::ExceptionAbstract &aea) {
output << aea.getExceptionName();
output2 << aea.what();
@@ -86,8 +88,8 @@ BOOST_AUTO_TEST_CASE(value_exceptions) {
res = false;
try {
bool abool(anet);
- abool = !abool; // silence unused variable warnings to have a stable release
- // in the ros buildfarm
+ abool = !abool; // silence unused variable warnings to have a stable
+ // release in the ros buildfarm
} catch (const dg::ExceptionAbstract &aea) {
res = (aea.getCode() == dg::ExceptionAbstract::TOOLS);
}
@@ -98,8 +100,8 @@ BOOST_AUTO_TEST_CASE(value_exceptions) {
res = false;
try {
unsigned int aint(anet);
- aint++; // silence unused variable warnings to have a stable release in the
- // ros buildfarm
+ aint++; // silence unused variable warnings to have a stable release in the
+ // ros buildfarm
} catch (const dg::ExceptionAbstract &aea) {
res = (aea.getCode() == dg::ExceptionAbstract::TOOLS);
}
@@ -110,8 +112,8 @@ BOOST_AUTO_TEST_CASE(value_exceptions) {
res = false;
try {
double adouble(anet);
- adouble++; // silence unused variable warnings to have a stable release in
- // the ros buildfarm
+ adouble++; // silence unused variable warnings to have a stable release in
+ // the ros buildfarm
} catch (const dg::ExceptionAbstract &aea) {
res = (aea.getCode() == dg::ExceptionAbstract::TOOLS);
}
@@ -122,8 +124,8 @@ BOOST_AUTO_TEST_CASE(value_exceptions) {
res = false;
try {
float afloat(anet);
- afloat++; // silence unused variable warnings to have a stable release in
- // the ros buildfarm
+ afloat++; // silence unused variable warnings to have a stable release in
+ // the ros buildfarm
} catch (const dg::ExceptionAbstract &aea) {
res = (aea.getCode() == dg::ExceptionAbstract::TOOLS);
}
@@ -368,17 +370,19 @@ BOOST_AUTO_TEST_CASE(value_matrix4d) {
{
output_test_stream output;
output << value1;
- BOOST_CHECK(output.is_equal("Type=matrix4d, value=0.5 1.5 0 0\n"
- "2.5 3.5 0 0\n 0 0 0 0\n"
- " 0 0 0 0"));
+ BOOST_CHECK(
+ output.is_equal("Type=matrix4d, value=0.5 1.5 0 0\n"
+ "2.5 3.5 0 0\n 0 0 0 0\n"
+ " 0 0 0 0"));
}
{
output_test_stream output;
output << value;
- BOOST_CHECK(output.is_equal("Type=matrix4d, value=0.5 1.5 0 0\n"
- "2.5 3.5 0 0\n 0 0 0 0\n"
- " 0 0 0 0"));
+ BOOST_CHECK(
+ output.is_equal("Type=matrix4d, value=0.5 1.5 0 0\n"
+ "2.5 3.5 0 0\n 0 0 0 0\n"
+ " 0 0 0 0"));
}
}
@@ -399,7 +403,7 @@ BOOST_AUTO_TEST_CASE(value_values) {
BOOST_CHECK_EQUAL(vvalues.type(), Value::VALUES);
- { // Const ref
+ { // Const ref
const Values &vs = vvalues.constValuesValue();
BOOST_CHECK_EQUAL(vs.size(), values.size());
BOOST_CHECK(vs == values);
@@ -410,7 +414,7 @@ BOOST_AUTO_TEST_CASE(value_values) {
// Values vs = static_cast<Values>(eitherType);
// BOOST_CHECK_EQUAL(vs.size(), values.size());
// BOOST_CHECK(vs == values);
- } { // Constructor
+ } { // Constructor
Value vvs(vvalues);
BOOST_CHECK(vvs == vvalues);
}
@@ -418,9 +422,10 @@ BOOST_AUTO_TEST_CASE(value_values) {
{
output_test_stream output;
output << vvalues;
- BOOST_CHECK(output.is_equal("Type=values, value=[ "
- "Value(Type=string, value=value #1), "
- "Value(Type=double, value=0.3), "
- "]"));
+ BOOST_CHECK(
+ output.is_equal("Type=values, value=[ "
+ "Value(Type=string, value=value #1), "
+ "Value(Type=double, value=0.3), "
+ "]"));
}
}
--
GitLab