Make format

include/aikido/constraint/FiniteSampleable.hpp

@@ -1,8 +1,8 @@
 #ifndef AIKIDO_CONSTRAINT_FINITESAMPLEABLE_HPP_
 #define AIKIDO_CONSTRAINT_FINITESAMPLEABLE_HPP_
 
-#include "Sampleable.hpp"
 #include "aikido/statespace/dart/MetaSkeletonStateSpace.hpp"
+#include "Sampleable.hpp"
 
 namespace aikido {
 namespace constraint {
@@ -18,15 +18,17 @@ class FiniteSampleable : public Sampleable
   /// \param _state The only sample in this constraint.
   FiniteSampleable(
       statespace::StateSpacePtr _stateSpace,
-      const aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState& _state);
+      const aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState&
+          _state);
 
   /// Constructor for multiple samples.
   /// \param _stateSpace StateSpace in which _states belong.
   /// \param _states Samples in this constraint.
   ///        SampleGenerator will generate samples in this order.
   FiniteSampleable(
       statespace::StateSpacePtr _stateSpace,
-      const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>& _states);
+      const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::
+                            ScopedState>& _states);
 
   FiniteSampleable(const FiniteSampleable& other) = delete;
   FiniteSampleable(FiniteSampleable&& other) = delete;
@@ -44,7 +46,8 @@ class FiniteSampleable : public Sampleable
 
 private:
   statespace::ConstStateSpacePtr mStateSpace;
-  std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState> mStates;
+  std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>
+      mStates;
 };
 
 } // namespace constraint

include/aikido/constraint/uniform/detail/RnConstantSampler-impl.hpp

@@ -124,8 +124,7 @@ template <int N>
 std::unique_ptr<constraint::SampleGenerator>
 RConstantSampler<N>::createSampleGenerator() const
 {
-  return std::make_unique<RnConstantSamplerSampleGenerator<N>>(
-      mSpace, mValue);
+  return std::make_unique<RnConstantSamplerSampleGenerator<N>>(mSpace, mValue);
 }
 
 //==============================================================================

include/aikido/distance/NominalConfigurationRanker.hpp

@@ -22,7 +22,8 @@ class NominalConfigurationRanker : public ConfigurationRanker
   /// \param[in] nominalConfiguration Nominal configuration. The current
   /// configuration of \c metaSkeleton is considered if set to \c nullptr.
   // NominalConfigurationRanker(
-  //     statespace::dart::ConstMetaSkeletonStateSpacePtr metaSkeletonStateSpace,
+  //     statespace::dart::ConstMetaSkeletonStateSpacePtr
+  //     metaSkeletonStateSpace,
   //     ::dart::dynamics::ConstMetaSkeletonPtr metaSkeleton,
   //     std::vector<double> weights = std::vector<double>(),
   //     const statespace::CartesianProduct::State* nominalConfiguration
@@ -34,7 +35,6 @@ class NominalConfigurationRanker : public ConfigurationRanker
       std::vector<double> weights,
       statespace::CartesianProduct::ScopedState nominalConfiguration);
 
-
 protected:
   /// Returns cost as distance from the Nominal Configuration.
   double evaluateConfiguration(

include/aikido/trajectory/util.hpp

@@ -1,10 +1,10 @@
 #ifndef AIKIDO_TRAJECTORY_UTIL_HPP_
 #define AIKIDO_TRAJECTORY_UTIL_HPP_
 
+#include <dart/dart.hpp>
+#include "aikido/statespace/dart/MetaSkeletonStateSpace.hpp"
 #include "aikido/trajectory/Interpolated.hpp"
 #include "aikido/trajectory/Spline.hpp"
-#include "aikido/statespace/dart/MetaSkeletonStateSpace.hpp"
-#include <dart/dart.hpp>
 
 namespace aikido {
 namespace trajectory {

src/constraint/FiniteSampleable.cpp

@@ -1,6 +1,6 @@
-#include <aikido/constraint/FiniteSampleable.hpp>
 #include <iostream>
 #include <dart/common/StlHelpers.hpp>
+#include <aikido/constraint/FiniteSampleable.hpp>
 
 namespace aikido {
 namespace constraint {
@@ -12,7 +12,8 @@ class FiniteSampleGenerator : public SampleGenerator
   // For internal use only.
   FiniteSampleGenerator(
       statespace::ConstStateSpacePtr _stateSpace,
-      const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>& _states);
+      const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::
+                            ScopedState>& _states);
 
   FiniteSampleGenerator(const FiniteSampleGenerator&) = delete;
   FiniteSampleGenerator(FiniteSampleGenerator&& other) = delete;
@@ -36,7 +37,8 @@ class FiniteSampleGenerator : public SampleGenerator
 
 private:
   statespace::ConstStateSpacePtr mStateSpace;
-  std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState> mStates;
+  std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>
+      mStates;
   int mIndex;
 
   friend class FiniteSampleable;
@@ -45,9 +47,9 @@ class FiniteSampleGenerator : public SampleGenerator
 //==============================================================================
 FiniteSampleGenerator::FiniteSampleGenerator(
     statespace::ConstStateSpacePtr _stateSpace,
-    const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>& _states)
-  : mStateSpace(std::move(_stateSpace))
-  , mIndex(0)
+    const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::
+                          ScopedState>& _states)
+  : mStateSpace(std::move(_stateSpace)), mIndex(0)
 {
   if (!mStateSpace)
     throw std::invalid_argument("StateSpacePtr is nullptr.");
@@ -117,7 +119,8 @@ FiniteSampleable::FiniteSampleable(
 //==============================================================================
 FiniteSampleable::FiniteSampleable(
     statespace::StateSpacePtr _stateSpace,
-    const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::ScopedState>& _states)
+    const std::vector<aikido::statespace::dart::MetaSkeletonStateSpace::
+                          ScopedState>& _states)
   : mStateSpace(std::move(_stateSpace))
 {
   if (!mStateSpace)
@@ -152,8 +155,7 @@ statespace::ConstStateSpacePtr FiniteSampleable::getStateSpace() const
 //==============================================================================
 std::unique_ptr<SampleGenerator> FiniteSampleable::createSampleGenerator() const
 {
-  return std::make_unique<FiniteSampleGenerator>(
-      mStateSpace, mStates);
+  return std::make_unique<FiniteSampleGenerator>(mStateSpace, mStates);
 }
 
 } // namespace constraint

src/constraint/SequentialSampleable.cpp

@@ -1,8 +1,8 @@
 #include "aikido/constraint/SequentialSampleable.hpp"
 
+#include <iostream>
 #include <dart/common/Console.hpp>
 #include <dart/common/Memory.hpp>
-#include <iostream>
 
 namespace aikido {
 namespace constraint {
@@ -93,7 +93,8 @@ bool SequentialSampleGenerator::sample(statespace::StateSpace::State* state)
     {
       // Eigen::VectorXd positions;
       // mStateSpace->logMap(state, positions);
-      // std::cout << "SequentialSampleGenerator " << mIndex << "/ " << mGenerators.size() << " "  << positions.transpose() << std::endl;
+      // std::cout << "SequentialSampleGenerator " << mIndex << "/ " <<
+      // mGenerators.size() << " "  << positions.transpose() << std::endl;
       return true;
     }
 

src/constraint/dart/CollisionFree.cpp

@@ -49,7 +49,8 @@ bool CollisionFree::isSatisfied(
   //   collisionFreeOutcome = new CollisionFreeOutcome();
   // }
   auto _outcome = this->createOutcome();
-  auto collisionFreeOutcome = dynamic_cast<CollisionFreeOutcome*>(_outcome.get());
+  auto collisionFreeOutcome
+      = dynamic_cast<CollisionFreeOutcome*>(_outcome.get());
 
   auto skelStatePtr = static_cast<const aikido::statespace::dart::
                                       MetaSkeletonStateSpace::State*>(_state);

src/constraint/dart/InverseKinematicsSampleable.cpp

@@ -220,12 +220,12 @@ bool IkSampleGenerator::sample(statespace::StateSpace::State* _state)
 
     mInverseKinematics->getTarget()->setTransform(poseState.getIsometry());
 
-    // Run the IK solver. If it succeeds, return the solution.
-    #if DART_VERSION_AT_LEAST(6, 8, 0)
+// Run the IK solver. If it succeeds, return the solution.
+#if DART_VERSION_AT_LEAST(6, 8, 0)
     if (mInverseKinematics->solveAndApply(true))
-    #else
+#else
     if (mInverseKinematics->solve(true))
-    #endif
+#endif
     {
       mMetaSkeletonStateSpace->getState(mMetaSkeleton.get(), outputState);
       return true;

src/control/ros/RosTrajectoryExecutor.cpp

@@ -150,7 +150,7 @@ std::future<void> RosTrajectoryExecutor::execute(
         goal,
         boost::bind(&RosTrajectoryExecutor::transitionCallback, this, _1));
 
-    std::cout <<  "Returning future" << std::endl;
+    std::cout << "Returning future" << std::endl;
     return mPromise->get_future();
   }
 }

src/distance/NominalConfigurationRanker.cpp

@@ -24,11 +24,11 @@ using ::dart::dynamics::ConstMetaSkeletonPtr;
 
 //==============================================================================
 NominalConfigurationRanker::NominalConfigurationRanker(
-      statespace::dart::ConstMetaSkeletonStateSpacePtr metaSkeletonStateSpace,
-      ::dart::dynamics::ConstMetaSkeletonPtr metaSkeleton,
-      std::vector<double> weights,
-      statespace::CartesianProduct::ScopedState nominalConfiguration)
-: ConfigurationRanker(
+    statespace::dart::ConstMetaSkeletonStateSpacePtr metaSkeletonStateSpace,
+    ::dart::dynamics::ConstMetaSkeletonPtr metaSkeleton,
+    std::vector<double> weights,
+    statespace::CartesianProduct::ScopedState nominalConfiguration)
+  : ConfigurationRanker(
         std::move(metaSkeletonStateSpace), std::move(metaSkeleton), weights)
   , mNominalConfiguration(std::move(nominalConfiguration))
 {

src/planner/kunzretimer/KunzRetimer.cpp

@@ -70,8 +70,7 @@ std::unique_ptr<aikido::trajectory::Spline> convertToSpline(
 
   // create spline
   auto outputTrajectory
-      = std::make_unique<aikido::trajectory::Spline>(
-          stateSpace, startTime);
+      = std::make_unique<aikido::trajectory::Spline>(stateSpace, startTime);
 
   // create a sequence of time steps from start time to end time by time step
   aikido::common::StepSequence sequence(

src/planner/ompl/Planner.cpp

@@ -477,9 +477,8 @@ std::unique_ptr<trajectory::Interpolated> toInterpolatedTrajectory(
     const ::ompl::geometric::PathGeometric& _path,
     statespace::InterpolatorPtr _interpolator)
 {
-  auto returnInterpolated
-      = std::make_unique<trajectory::Interpolated>(
-          _interpolator->getStateSpace(), std::move(_interpolator));
+  auto returnInterpolated = std::make_unique<trajectory::Interpolated>(
+      _interpolator->getStateSpace(), std::move(_interpolator));
 
   for (std::size_t idx = 0; idx < _path.getStateCount(); ++idx)
   {

src/planner/vectorfield/VectorFieldUtil.cpp

@@ -129,11 +129,12 @@ bool computeJointVelocityFromTwist(
       dart::common::make_aligned_shared<DesiredTwistFunction>(
           desiredTwist, jacobian));
 
-  #if DART_VERSION_AT_LEAST(6, 9, 0)
-  dart::optimizer::NloptSolver solver(problem, dart::optimizer::NloptSolver::Algorithm::LD_LBFGS);
-  #else
+#if DART_VERSION_AT_LEAST(6, 9, 0)
+  dart::optimizer::NloptSolver solver(
+      problem, dart::optimizer::NloptSolver::Algorithm::LD_LBFGS);
+#else
   dart::optimizer::NloptSolver solver(problem, nlopt::LD_LBFGS);
-  #endif
+#endif
   if (!solver.solve())
   {
     return false;

src/planner/vectorfield/detail/VectorFieldIntegrator.cpp

@@ -53,9 +53,8 @@ std::unique_ptr<aikido::trajectory::Interpolated> convertToInterpolated(
   auto interpolator
       = std::make_shared<const aikido::statespace::GeodesicInterpolator>(
           stateSpace);
-  auto outputTrajectory
-      = std::make_unique<aikido::trajectory::Interpolated>(
-          stateSpace, interpolator);
+  auto outputTrajectory = std::make_unique<aikido::trajectory::Interpolated>(
+      stateSpace, interpolator);
 
   auto currState = stateSpace->createState();
   for (const auto& knot : knots)