changes made to build without warnings

CMakeLists.txt

@@ -152,7 +152,6 @@ include(CompilerSettings)
 #==============================================================================
 # Libraries and unit tests.
 #
-
 configure_file(
   ${CMAKE_MODULE_PATH}/version.hpp.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/aikido/version.hpp

cmake/CompilerSettings.cmake

@@ -17,6 +17,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 
   set(AIKIDO_CXX_STANDARD_FLAGS -std=c++11)
 
+  add_compile_options(-Wall)
+  add_compile_options(-Wpedantic)
   if(TREAT_WARNINGS_AS_ERRORS)
     add_compile_options(-Werror)
   endif()
@@ -33,6 +35,7 @@ elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 
   set(AIKIDO_CXX_STANDARD_FLAGS -std=c++11)
 
+  add_compile_options(-Wall)
   if(TREAT_WARNINGS_AS_ERRORS)
     add_compile_options(-Werror)
   endif()
@@ -49,6 +52,7 @@ elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
 
   set(AIKIDO_CXX_STANDARD_FLAGS -std=c++11)
 
+  add_compile_options(-Wall)
   if(TREAT_WARNINGS_AS_ERRORS)
     add_compile_options(-Werror)
   endif()
@@ -64,6 +68,7 @@ elseif(MSVC)
    # C++11 (e.g., -std=c++11) since Visual Studio enables it by default when
    # available.
 
+  add_compile_options(/Wall)
   if(TREAT_WARNINGS_AS_ERRORS)
     add_compile_options(/WX)
   endif()

include/aikido/constraint/NewtonsMethodProjectable.hpp

@@ -38,10 +38,10 @@ class NewtonsMethodProjectable : public Projectable
 
 private:
   DifferentiablePtr mDifferentiable;
-  statespace::StateSpacePtr mStateSpace;
-  int mMaxIteration;
   std::vector<double> mTolerance;
+  int mMaxIteration;
   double mMinStepSize;
+  statespace::StateSpacePtr mStateSpace;
 
   bool contains(const statespace::StateSpace::State* _s) const;
 };

include/aikido/distance/SO2Angular.hpp

@@ -29,6 +29,6 @@ class SO2Angular : public DistanceMetric
 private:
   std::shared_ptr<statespace::SO2> mStateSpace;
 };
-};
+}
 }
 #endif

include/aikido/distance/SO3Angular.hpp

@@ -29,6 +29,6 @@ class SO3Angular : public DistanceMetric
 private:
   std::shared_ptr<statespace::SO3> mStateSpace;
 };
-};
+}
 }
 #endif

include/aikido/util/Spline.hpp

@@ -163,7 +163,7 @@ class SplineND
   SolutionMatrices mSolution;
 
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(TimeVector::NeedsToAlign);
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(TimeVector::NeedsToAlign) 
 };
 
 
@@ -330,7 +330,7 @@ class SplineProblem
     || TimeVector::NeedsToAlign
     || ProblemMatrix::NeedsToAlign
     || ProblemVector::NeedsToAlign
-  );
+  ) 
 };
 
 } // namespace util

include/aikido/util/StepSequence.hpp

@@ -54,7 +54,7 @@ class StepSequence::const_iterator
   bool equal(const StepSequence::const_iterator &other) const;
 
 private:
-  friend StepSequence;
+  friend class StepSequence;
 
   const_iterator(StepSequence *seq, int step)
       : mSeq(seq)

src/constraint/CartesianProductTestable.cpp

@@ -17,7 +17,7 @@ CartesianProductTestable::CartesianProductTestable(
   if (!mStateSpace)
     throw std::invalid_argument("_stateSpace is nullptr.");
 
-  for(int i = 0; i < mConstraints.size(); ++i)
+  for(size_t i = 0; i < mConstraints.size(); ++i)
   {
     if (!mConstraints[i])
     {

src/constraint/FiniteSampleable.cpp

@@ -95,7 +95,7 @@ statespace::StateSpacePtr FiniteSampleGenerator::getStateSpace() const
 //=============================================================================
 bool FiniteSampleGenerator::sample(statespace::StateSpace::State* _state)
 {
-  if (mStates.size() <= mIndex)
+  if (mStates.size() <= static_cast<size_t>(mIndex))
     return false;
 
   mStateSpace->copyState(mStates[mIndex], _state);
@@ -113,7 +113,7 @@ int FiniteSampleGenerator::getNumSamples() const
 //=============================================================================
 bool FiniteSampleGenerator::canSample() const
 {
-  return mStates.size() > mIndex;
+  return mStates.size() > static_cast<size_t>(mIndex); 
 }
 
 //=============================================================================

src/constraint/NewtonsMethodProjectable.cpp

@@ -76,7 +76,6 @@ bool NewtonsMethodProjectable::project(
   statespace::StateSpace::State* _out) const
 {
   using StateSpace = statespace::StateSpace;
-  using State = StateSpace::State;
 
   int iteration = 0;
 

src/constraint/TSR.cpp

@@ -80,57 +80,58 @@ class TSRSampleGenerator : public SampleGenerator
 //=============================================================================
 TSR::TSR(std::unique_ptr<util::RNG> _rng, const Eigen::Isometry3d& _T0_w,
          const Eigen::Matrix<double, 6, 2>& _Bw, const Eigen::Isometry3d& _Tw_e)
-    : mRng(std::move(_rng))
-    , mStateSpace(std::make_shared<SE3>())
-    , mT0_w(_T0_w)
+    : mT0_w(_T0_w)
     , mBw(_Bw)
     , mTw_e(_Tw_e)
+    , mRng(std::move(_rng))
+    , mStateSpace(std::make_shared<SE3>())
 {
   validate();
 }
 
 //=============================================================================
 TSR::TSR(const Eigen::Isometry3d& _T0_w, const Eigen::Matrix<double, 6, 2>& _Bw,
          const Eigen::Isometry3d& _Tw_e)
-    : mRng(std::unique_ptr<util::RNG>(
-          new util::RNGWrapper<std::default_random_engine>(0)))
-    , mStateSpace(std::make_shared<SE3>())
-    , mT0_w(_T0_w)
+    : mT0_w(_T0_w)
     , mBw(_Bw)
     , mTw_e(_Tw_e)
+    , mRng(std::unique_ptr<util::RNG>(
+          new util::RNGWrapper<std::default_random_engine>(0)))
+    , mStateSpace(std::make_shared<SE3>())
 {
   validate();
 }
 
 //=============================================================================
 TSR::TSR(const TSR& other)
-    : mRng(std::move(other.mRng->clone()))
-    , mStateSpace(std::make_shared<SE3>())
-    , mT0_w(other.mT0_w)
-    , mTw_e(other.mTw_e)
+    : mT0_w(other.mT0_w)
     , mBw(other.mBw)
+    , mTw_e(other.mTw_e)
+    , mRng(std::move(other.mRng->clone()))
+    , mStateSpace(std::make_shared<SE3>())
 {
   validate();
 }
 
 //=============================================================================
 TSR::TSR(TSR&& other)
-    : mRng(std::move(other.mRng))
-    , mStateSpace(std::make_shared<SE3>())
-    , mT0_w(other.mT0_w)
-    , mTw_e(other.mTw_e)
+    : mT0_w(other.mT0_w)
     , mBw(other.mBw)
+    , mTw_e(other.mTw_e)
+    , mRng(std::move(other.mRng))
+    , mStateSpace(std::make_shared<SE3>())
 {
   validate();
 }
 
 //=============================================================================
 TSR& TSR::operator=(const TSR& other)
 {
-  mRng = std::move(other.mRng->clone());
+
   mT0_w = other.mT0_w;
-  mTw_e = other.mTw_e;
   mBw = other.mBw;
+  mTw_e = other.mTw_e;
+  mRng = std::move(other.mRng->clone());
 
   // Intentionally don't assign StateSpace.
 
@@ -140,11 +141,11 @@ TSR& TSR::operator=(const TSR& other)
 //=============================================================================
 TSR& TSR::operator=(TSR&& other)
 {
-  mRng = std::move(other.mRng);
-  mStateSpace = std::move(other.mStateSpace);
   mT0_w = std::move(other.mT0_w);
-  mTw_e = std::move(other.mTw_e);
   mBw = std::move(other.mBw);
+  mTw_e = std::move(other.mTw_e);
+  mRng = std::move(other.mRng);
+  mStateSpace = std::move(other.mStateSpace);
 
   return *this;
 }

src/constraint/uniform/RnBoxConstraint.cpp

@@ -61,7 +61,7 @@ bool RnBoxConstraintSampleGenerator::sample(
 {
   Eigen::VectorXd value(mDistributions.size());
 
-  for (size_t i = 0; i < value.size(); ++i)
+  for (int i = 0; i < value.size(); ++i) 
     value[i] = mDistributions[i](*mRng);
 
   mSpace->setValue(static_cast<statespace::Rn::State*>(_state), value);
@@ -98,15 +98,15 @@ RnBoxConstraint
 
   const auto dimension = mSpace->getDimension();
 
-  if (mLowerLimits.size() != dimension)
+  if (static_cast<size_t>(mLowerLimits.size()) != dimension) 
   {
     std::stringstream msg;
     msg << "Lower limits have incorrect dimension: expected "
         << mSpace->getDimension() << ", got " << mLowerLimits.size() << ".";
     throw std::invalid_argument(msg.str());
   }
 
-  if (mUpperLimits.size() != dimension)
+  if (static_cast<size_t>(mUpperLimits.size()) != dimension)
   {
     std::stringstream msg;
     msg << "Upper limits have incorrect dimension: expected "
@@ -153,7 +153,7 @@ bool RnBoxConstraint::isSatisfied(const statespace::StateSpace::State* state) co
   const auto value = mSpace->getValue(
     static_cast<const statespace::Rn::State*>(state));
 
-  for (size_t i = 0; i < value.size(); ++i)
+  for (int i = 0; i < value.size(); ++i)
   {
     if (value[i] < mLowerLimits[i] || value[i] > mUpperLimits[i])
       return false;
@@ -169,7 +169,7 @@ bool RnBoxConstraint::project(
   Eigen::VectorXd value = mSpace->getValue(
     static_cast<const statespace::Rn::State*>(_s));
 
-  for (size_t i = 0; i < value.size(); ++i)
+  for (int i = 0; i < value.size(); ++i)
   {
     if (value[i] < mLowerLimits[i])
       value[i] = mLowerLimits[i];
@@ -217,7 +217,7 @@ void RnBoxConstraint::getJacobian(
   const size_t dimension = mSpace->getDimension();
   _out = Eigen::MatrixXd::Zero(dimension, dimension);
 
-  for (size_t i = 0; i < _out.rows(); ++i)
+  for (int i = 0; i < _out.rows(); ++i)
   {
     if (stateValue[i] < mLowerLimits[i])
       _out(i, i) = -1.;

src/control/BarrettFingerPositionCommandExecutor.cpp

@@ -24,10 +24,10 @@ BarrettFingerPositionCommandExecutor::BarrettFingerPositionCommandExecutor(
 
   const auto numDofs = mFinger->getNumDofs();
 
-  if (_proximal < numDofs)
+  if (static_cast<size_t>(_proximal) < numDofs)
     mProximalDof = mFinger->getDof(_proximal);
 
-  if (_distal < numDofs)
+  if (static_cast<size_t>(_distal) < numDofs)
     mDistalDof = mFinger->getDof(_distal);
 
   if (!mProximalDof)

src/control/BarrettFingerSpreadCommandExecutor.cpp

@@ -34,7 +34,7 @@ BarrettFingerSpreadCommandExecutor::BarrettFingerSpreadCommandExecutor(
     }
 
     const auto numDofs = mFingers[i]->getNumDofs();
-    if (_spread >= numDofs)
+    if (static_cast<size_t>(_spread) >= numDofs)
       throw std::invalid_argument("Finger does not have spread dof.");
 
     mSpreadDofs.push_back(mFingers[i]->getDof(_spread));

src/control/BarrettHandPositionCommandExecutor.cpp

@@ -79,7 +79,7 @@ void BarrettHandPositionCommandExecutor::step(double _timeSincePreviousCall)
   std::exception_ptr expr;
   bool allFingersCompleted = true;
 
-  for(int i = 0; i < mFingerFutures.size(); ++i)
+  for(size_t i = 0; i < mFingerFutures.size(); ++i)
   {
     // Check the status of each finger
     auto status = mFingerFutures[i].wait_for(kWaitPeriod);
@@ -92,7 +92,7 @@ void BarrettHandPositionCommandExecutor::step(double _timeSincePreviousCall)
 
   if (allFingersCompleted)
   {
-    for(int i = 0; i < mFingerFutures.size(); ++i)
+    for(size_t i = 0; i < mFingerFutures.size(); ++i)
     {
       try{
         mFingerFutures[i].get();

src/control/KinematicSimulationTrajectoryExecutor.cpp

@@ -14,11 +14,13 @@ KinematicSimulationTrajectoryExecutor::KinematicSimulationTrajectoryExecutor(
   ::dart::dynamics::SkeletonPtr _skeleton,
   std::chrono::milliseconds _period)
 : mSkeleton(std::move(_skeleton))
-, mSpinMutex()
-, mRunning(true)
 , mPromise(nullptr)
 , mTraj(nullptr)
 , mPeriod(_period)
+, mSpinMutex()
+, mRunning(true)
+
+
 {
   using std::chrono::duration;
   using std::chrono::duration_cast;

src/external/hauser_parabolic_smoother/CMakeLists.txt

@@ -11,4 +11,5 @@ set_target_properties("${PROJECT_NAME}_external_hauserparabolicsmoother"
 )
 target_compile_options("${PROJECT_NAME}_external_hauserparabolicsmoother"
   PUBLIC ${AIKIDO_CXX_STANDARD_FLAGS}
+  PRIVATE -w
 )

src/external/hauser_parabolic_smoother/DynamicPath.cpp

@@ -193,7 +193,7 @@ void DynamicPath::SetMilestones(const vector<Vector>& x)
       ramps[i].x1 = x[i+1];
       ramps[i].dx0 = zero;
       ramps[i].dx1 = zero;
-      bool res=ramps[i].SolveMinTimeLinear(accMax,velMax);
+      bool res = ramps[i].SolveMinTimeLinear(accMax,velMax);
       PARABOLIC_RAMP_ASSERT(res);
     }
   }

src/external/hauser_parabolic_smoother/ParabolicRamp.cpp

@@ -142,7 +142,7 @@ void TestRamps(const char* fn)
   while(LoadRamp(f,ramp.x0,ramp.dx0,ramp.x1,ramp.dx1,a,v,t)) {
     if(t < 0) {
       PARABOLIC_RAMP_ASSERT( a >= 0 && v >= 0);
-      bool res=ramp.SolveMinTime(a,v);
+      bool res = ramp.SolveMinTime(a,v);
       PARABOLIC_RAMP_PLOG("Result %d: t=%g\n",(int)res,ramp.ttotal);
     }
     else if(a < 0) {

src/perception/AprilTagsModule.cpp

@@ -22,12 +22,12 @@ namespace perception{
 AprilTagsModule::AprilTagsModule( ros::NodeHandle node, std::string markerTopic, std::shared_ptr<AprilTagsDatabase> configData,
 								  const dart::common::ResourceRetrieverPtr resourceRetriever,	
 								  std::string referenceFrameId, dart::dynamics::Frame* referenceLink):
-		mNode(std::move(node)),
 		mMarkerTopic(std::move(markerTopic)),
-		mConfigData(std::move(configData)),
-		mResourceRetriever(std::move(resourceRetriever)),
 		mReferenceFrameId(std::move(referenceFrameId)),
+		mResourceRetriever(std::move(resourceRetriever)),
 		mReferenceLink(std::move(referenceLink)),
+		mConfigData(std::move(configData)),
+		mNode(std::move(node)),
 		mListener(mNode)
 {
 }

src/planner/ompl/CRRT.cpp

@@ -13,8 +13,8 @@ CRRT::CRRT(const ::ompl::base::SpaceInformationPtr &_si) : CRRT(_si, "CRRT") {}
 //=============================================================================
 CRRT::CRRT(const ::ompl::base::SpaceInformationPtr &_si,
            const std::string &name)
-    : ::ompl::base::Planner(_si, name), mCons(nullptr), mGoalBias(0.05),
-      mMaxDistance(0.1), mLastGoalMotion(nullptr), mMaxStepsize(0.1), mMinStepsize(1e-4) {
+    : ::ompl::base::Planner(_si, name), mGoalBias(0.05), mMaxDistance(0.1), 
+    mLastGoalMotion(nullptr), mCons(nullptr), mMaxStepsize(0.1), mMinStepsize(1e-4) {
 
   auto ss =
       ompl_dynamic_pointer_cast<GeometricStateSpace>(si_->getStateSpace());