Use only shared pointers for Problem.

  Constructors that used to take const Problem& as input now take
  const ProblemConstPtr_t.
  Classes that used to store a const Problem& now store a
  ProblemConstWkPtr_t.

include/hpp/core/bi-rrt-planner.hh

@@ -34,18 +34,19 @@ namespace hpp {
     public:
       /// Return shared pointer to new object.
       static BiRRTPlannerPtr_t createWithRoadmap
-	(const Problem& problem, const RoadmapPtr_t& roadmap);
+	(const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
       /// Return shared pointer to new object.
-      static BiRRTPlannerPtr_t create (const Problem& problem);
+      static BiRRTPlannerPtr_t create (const ProblemConstPtr_t& problem);
       /// One step of extension.
       virtual void startSolve();
       /// One step of extension.
       virtual void oneStep ();
     protected:
       /// Constructor
-      BiRRTPlanner (const Problem& problem, const RoadmapPtr_t& roadmap);
+      BiRRTPlanner (const ProblemConstPtr_t& problem,
+		    const RoadmapPtr_t& roadmap);
       /// Constructor with roadmap
-      BiRRTPlanner (const Problem& problem);
+      BiRRTPlanner (const ProblemConstPtr_t& problem);
       /// Store weak pointer to itself
       void init (const BiRRTPlannerWkPtr_t& weak);
       PathPtr_t extendInternal (const SteeringMethodPtr_t& sm, Configuration_t& qProj_, const NodePtr_t& near,

include/hpp/core/diffusing-planner.hh

@@ -32,18 +32,18 @@ namespace hpp {
     public:
       /// Return shared pointer to new object.
       static DiffusingPlannerPtr_t createWithRoadmap
-	(const Problem& problem, const RoadmapPtr_t& roadmap);
+	(const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
       /// Return shared pointer to new object.
-      static DiffusingPlannerPtr_t create (const Problem& problem);
+      static DiffusingPlannerPtr_t create (const ProblemConstPtr_t& problem);
       /// One step of extension.
       virtual void oneStep ();
       /// Set configuration shooter.
       void configurationShooter (const ConfigurationShooterPtr_t& shooter);
     protected:
       /// Constructor
-      DiffusingPlanner (const Problem& problem, const RoadmapPtr_t& roadmap);
+      DiffusingPlanner (const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
       /// Constructor with roadmap
-      DiffusingPlanner (const Problem& problem);
+      DiffusingPlanner (const ProblemConstPtr_t& problem);
       /// Store weak pointer to itself
       void init (const DiffusingPlannerWkPtr_t& weak);
       /// Extend a node in the direction of a configuration

include/hpp/core/distance/reeds-shepp.hh

@@ -36,15 +36,15 @@ namespace hpp {
       {
       public:
 	virtual DistancePtr_t clone () const;
-	static ReedsSheppPtr_t create (const Problem& problem);
-	static ReedsSheppPtr_t create (const Problem& problem,
+	static ReedsSheppPtr_t create (const ProblemConstPtr_t& problem);
+	static ReedsSheppPtr_t create (const ProblemConstPtr_t& problem,
 				     const value_type& turningRadius,
 				     JointPtr_t xyJoint, JointPtr_t rzJoint);
 
 	static ReedsSheppPtr_t createCopy (const ReedsSheppPtr_t& distance);
       protected:
-	ReedsShepp (const Problem& problem);
-	ReedsShepp (const Problem& problem,
+	ReedsShepp (const ProblemConstPtr_t& problem);
+	ReedsShepp (const ProblemConstPtr_t& problem,
 		    const value_type& turningRadius,
 		    JointPtr_t xyJoint, JointPtr_t rzJoint);
 	ReedsShepp (const ReedsShepp& distance);

include/hpp/core/fwd.hh

@@ -177,6 +177,7 @@ namespace hpp {
     typedef boost::shared_ptr <const PathVector> PathVectorConstPtr_t;
     typedef boost::shared_ptr <PlanAndOptimize> PlanAndOptimizePtr_t;
     typedef boost::shared_ptr <Problem> ProblemPtr_t;
+    typedef boost::shared_ptr <const Problem> ProblemConstPtr_t;
     typedef ProblemSolver* ProblemSolverPtr_t;
     typedef boost::shared_ptr <Roadmap> RoadmapPtr_t;
     typedef boost::shared_ptr <StraightPath> StraightPathPtr_t;

include/hpp/core/kinodynamic-distance.hh

@@ -37,7 +37,8 @@ namespace core {
 class HPP_CORE_DLLAPI KinodynamicDistance : public Distance {
 public:
     static KinodynamicDistancePtr_t create (const DevicePtr_t& robot);
-    static KinodynamicDistancePtr_t createFromProblem (const Problem& problem);
+    static KinodynamicDistancePtr_t createFromProblem
+      (const ProblemConstPtr_t& problem);
 
     static KinodynamicDistancePtr_t createCopy
     (const KinodynamicDistancePtr_t& distance);
@@ -51,7 +52,7 @@ public:
     }
 protected:
     KinodynamicDistance (const DevicePtr_t& robot);
-    KinodynamicDistance (const Problem& problem);
+    KinodynamicDistance (const ProblemConstPtr_t& problem);
     KinodynamicDistance (const KinodynamicDistance& distance);
     void init (KinodynamicDistanceWkPtr_t self);
     /// Derived class should implement this function

include/hpp/core/parser/roadmap-factory.hh

@@ -77,7 +77,11 @@ namespace hpp {
               const RoadmapPtr_t& roadmap, ObjectFactory* parent = NULL);
 
         private:
-          ProblemPtr_t problem_;
+	  ProblemPtr_t problem() const
+	  {
+	    return problem_.lock();
+	  }
+          ProblemWkPtr_t problem_;
 
           void computePermutation (const std::vector <std::string>& jointNames);
           ConfigurationPtr_t permuteAndCreateConfiguration

include/hpp/core/path-optimization/config-optimization.hh

@@ -61,10 +61,12 @@ namespace hpp {
         public:
           /// Return shared pointer to new object.
           template < typename Traits > static
-            ConfigOptimizationPtr_t createWithTraits (const Problem& problem);
+            ConfigOptimizationPtr_t createWithTraits
+	    (const ProblemConstPtr_t& problem);
 
           /// Return shared pointer to new object.
-          static ConfigOptimizationPtr_t create (const Problem& problem);
+          static ConfigOptimizationPtr_t create
+	    (const ProblemConstPtr_t& problem);
 
           /// Optimize path
           virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
@@ -92,7 +94,7 @@ namespace hpp {
           } parameters;
 
         protected:
-          ConfigOptimization (const Problem& problem);
+          ConfigOptimization (const ProblemConstPtr_t& problem);
 
           virtual constraints::ImplicitPtr_t createNumConstraint
             (const PathVector& path) const;
@@ -123,7 +125,7 @@ namespace hpp {
       /// \}
 
       template < typename Traits > ConfigOptimizationPtr_t
-        ConfigOptimization::createWithTraits (const Problem& problem)
+        ConfigOptimization::createWithTraits (const ProblemConstPtr_t& problem)
       {
         ConfigOptimization* ptr = new ConfigOptimization (problem);
         ptr->parameters.addConfigConstraintToPath =

include/hpp/core/path-optimization/gradient-based.hh

@@ -37,13 +37,13 @@ namespace hpp {
       public:
 	/// Return shared pointer to new object.
 	/// Default cost is path length.
-	static GradientBasedPtr_t create (const Problem& problem);
+	static GradientBasedPtr_t create (const ProblemConstPtr_t& problem);
 
 	/// Optimize path
 	virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
 
       protected:
-	GradientBased (const Problem& problem);
+	GradientBased (const ProblemConstPtr_t& problem);
 
       private:
 	typedef Eigen::JacobiSVD < matrix_t > Jacobi_t;

include/hpp/core/path-optimization/partial-shortcut.hh

@@ -58,10 +58,11 @@ namespace hpp {
         public:
           /// Return shared pointer to new object.
           template < typename Traits > static
-            PartialShortcutPtr_t createWithTraits (const Problem& problem);
+            PartialShortcutPtr_t createWithTraits
+	      (const ProblemConstPtr_t& problem);
 
           /// Return shared pointer to new object.
-          static PartialShortcutPtr_t create (const Problem& problem);
+          static PartialShortcutPtr_t create (const ProblemConstPtr_t& problem);
 
           /// Optimize path
           virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
@@ -91,7 +92,7 @@ namespace hpp {
           } parameters;
 
         protected:
-          PartialShortcut (const Problem& problem);
+          PartialShortcut (const ProblemConstPtr_t& problem);
 
         private:
           PathVectorPtr_t generatePath (PathVectorPtr_t path, JointConstPtr_t joint,
@@ -119,7 +120,7 @@ namespace hpp {
       /// \}
 
       template < typename Traits > PartialShortcutPtr_t
-        PartialShortcut::createWithTraits (const Problem& problem)
+        PartialShortcut::createWithTraits (const ProblemConstPtr_t& problem)
       {
         PartialShortcut* ptr = new PartialShortcut (problem);
         ptr->parameters.removeLockedJoints = Traits::removeLockedJoints();

include/hpp/core/path-optimization/random-shortcut.hh

@@ -39,12 +39,12 @@ namespace hpp {
     {
     public:
       /// Return shared pointer to new object.
-      static RandomShortcutPtr_t create (const Problem& problem);
+      static RandomShortcutPtr_t create (const ProblemConstPtr_t& problem);
 
       /// Optimize path
       virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
     protected:
-      RandomShortcut (const Problem& problem);
+      RandomShortcut (const ProblemConstPtr_t& problem);
 
       /// Sample times along currentOpt
       /// \param currentOpt the current path

include/hpp/core/path-optimization/simple-shortcut.hh

@@ -38,12 +38,12 @@ namespace hpp {
       {
       public:
         /// Return shared pointer to new object.
-        static SimpleShortcutPtr_t create (const Problem& problem);
+        static SimpleShortcutPtr_t create (const ProblemConstPtr_t& problem);
 
         /// Optimize path
         virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
       protected:
-        SimpleShortcut (const Problem& problem);
+        SimpleShortcut (const ProblemConstPtr_t& problem);
       }; // class SimpleShortcut
       /// \}
     } // namespace pathOptimization

include/hpp/core/path-optimization/simple-time-parameterization.hh

@@ -176,13 +176,14 @@ namespace hpp {
       {
         public:
           /// Return shared pointer to new object.
-          static SimpleTimeParameterizationPtr_t create (const Problem& problem);
+          static SimpleTimeParameterizationPtr_t create
+	    (const ProblemConstPtr_t& problem);
 
           /// Optimize path
           virtual PathVectorPtr_t optimize (const PathVectorPtr_t& path);
 
         protected:
-          SimpleTimeParameterization (const Problem& problem);
+          SimpleTimeParameterization (const ProblemConstPtr_t& problem);
       }; // class SimpleTimeParameterization
       /// \}
     } // namespace pathOptimization

include/hpp/core/path-optimization/spline-gradient-based-abstract.hh

@@ -71,7 +71,7 @@ namespace hpp {
 
         protected:
 
-          SplineGradientBasedAbstract (const Problem& problem);
+          SplineGradientBasedAbstract (const ProblemConstPtr_t& problem);
 
           /// \name Spline creation
           /// \{

include/hpp/core/path-optimization/spline-gradient-based.hh

@@ -50,7 +50,7 @@ namespace hpp {
 
           /// Return shared pointer to new object.
           /// Default cost is path length.
-          static Ptr_t create (const Problem& problem);
+          static Ptr_t create (const ProblemConstPtr_t& problem);
 
           /// Optimize path
           /// \li 1) Transform straight paths into splines
@@ -74,7 +74,7 @@ namespace hpp {
           using Base::robot_;
           using Base::problem;
 
-          SplineGradientBased (const Problem& problem);
+          SplineGradientBased (const ProblemConstPtr_t& problem);
 
           /// \name Constraint creation
           /// \{

include/hpp/core/path-optimizer.hh

@@ -37,7 +37,7 @@ namespace hpp {
       virtual ~PathOptimizer () {};
 
       /// Get problem
-      const Problem& problem () const
+      ProblemConstPtr_t problem () const
       {
 	return problem_;
       }
@@ -58,7 +58,7 @@ namespace hpp {
       /// interrupt.
       bool interrupt_;
 
-      PathOptimizer (const Problem& problem);
+      PathOptimizer (const ProblemConstPtr_t& problem);
 
       PathPtr_t steer (ConfigurationIn_t q1, ConfigurationIn_t q2) const;
 
@@ -71,7 +71,7 @@ namespace hpp {
       void initFromParameters ();
 
     private:
-      const Problem& problem_;
+      ProblemConstPtr_t problem_;
 
       /// Maximal number of iterations to solve a problem
       /// reaching this bound raises an exception.

include/hpp/core/path-planner.hh

@@ -33,12 +33,12 @@ namespace hpp {
     /// set of goal configurations.
     class HPP_CORE_DLLAPI PathPlanner {
     public:
-      virtual ~PathPlanner () {};
+      virtual ~PathPlanner ();
 
       /// Get roadmap
       virtual const RoadmapPtr_t& roadmap () const;
       /// Get problem
-      const Problem& problem () const;
+      ProblemConstPtr_t problem () const;
       /// Initialize the problem resolution
       ///  \li Set initial and and goal nodes,
       ///  \li check problem consistency
@@ -80,16 +80,17 @@ namespace hpp {
       /// Constructor
       ///
       /// Create a new roadmap
-      PathPlanner (const Problem& problem);
+      PathPlanner (const ProblemConstPtr_t& problem);
       /// Constructor
       ///
       /// Store a given roadmap.
-      PathPlanner (const Problem& problem, const RoadmapPtr_t& roadmap);
+      PathPlanner (const ProblemConstPtr_t& problem,
+		   const RoadmapPtr_t& roadmap);
       /// Store weak pointer to itself
       void init (const PathPlannerWkPtr_t& weak);
     private:
       /// Reference to the problem
-      const Problem& problem_;
+      const ProblemConstWkPtr_t problem_;
       /// Pointer to the roadmap.
       const RoadmapPtr_t roadmap_;
       bool interrupt_;

include/hpp/core/path-planner/bi-rrt-star.hh

@@ -36,12 +36,12 @@ namespace hpp {
 
         /// Return shared pointer to new instance
         /// \param problem the path planning problem
-        static BiRrtStarPtr_t create (const Problem& problem);
+        static BiRrtStarPtr_t create (const ProblemConstPtr_t& problem);
         /// Return shared pointer to new instance
         /// \param problem the path planning problem
         /// \param roadmap previously built roadmap
-        static BiRrtStarPtr_t createWithRoadmap (const Problem& problem,
-                                                const RoadmapPtr_t& roadmap);
+        static BiRrtStarPtr_t createWithRoadmap
+	  (const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
 
         /// Initialize the problem resolution
         ///  \li call parent implementation
@@ -52,11 +52,11 @@ namespace hpp {
       protected:
         /// Protected constructor
         /// \param problem the path planning problem
-        BiRrtStar (const Problem& problem);
+        BiRrtStar (const ProblemConstPtr_t& problem);
         /// Protected constructor
         /// \param problem the path planning problem
         /// \param roadmap previously built roadmap
-        BiRrtStar (const Problem& problem, const RoadmapPtr_t& roadmap);
+        BiRrtStar (const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
         /// Store weak pointer to itself
         void init (const BiRrtStarWkPtr_t& weak);
 

include/hpp/core/path-planner/k-prm-star.hh

@@ -41,12 +41,12 @@ namespace hpp {
         typedef PathPlanner Parent_t;
         /// Return shared pointer to new instance
         /// \param problem the path planning problem
-        static kPrmStarPtr_t create (const Problem& problem);
+        static kPrmStarPtr_t create (const ProblemConstPtr_t& problem);
         /// Return shared pointer to new instance
         /// \param problem the path planning problem
         /// \param roadmap previously built roadmap
-        static kPrmStarPtr_t createWithRoadmap (const Problem& problem,
-                                                const RoadmapPtr_t& roadmap);
+        static kPrmStarPtr_t createWithRoadmap
+	  (const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
       /// Initialize the problem resolution
       ///  \li call parent implementation
       ///  \li get number nodes in problem parameter map
@@ -59,11 +59,11 @@ namespace hpp {
       protected:
         /// Protected constructor
         /// \param problem the path planning problem
-        kPrmStar (const Problem& problem);
+        kPrmStar (const ProblemConstPtr_t& problem);
         /// Protected constructor
         /// \param problem the path planning problem
         /// \param roadmap previously built roadmap
-        kPrmStar (const Problem& problem, const RoadmapPtr_t& roadmap);
+        kPrmStar (const ProblemConstPtr_t& problem, const RoadmapPtr_t& roadmap);
         /// Store weak pointer to itself
         void init (const kPrmStarWkPtr_t& weak);
 

include/hpp/core/path-projector/dichotomy.hh

@@ -39,10 +39,11 @@ namespace hpp {
           }
 
           static DichotomyPtr_t create
-	    (const Problem& problem,
+	    (const ProblemConstPtr_t& problem,
 	     value_type maxPathLength)
           {
-            return create (problem.distance(), problem.steeringMethod(), maxPathLength);
+            return create (problem->distance(), problem->steeringMethod(),
+			   maxPathLength);
           }
 
         protected:

include/hpp/core/path-projector/global.hh

@@ -41,7 +41,7 @@ namespace hpp {
           static GlobalPtr_t create (const DistancePtr_t& distance,
 	     const SteeringMethodPtr_t& steeringMethod, value_type step);
 
-          static GlobalPtr_t create (const Problem& problem,
+          static GlobalPtr_t create (const ProblemConstPtr_t& problem,
               const value_type& step);
 
         protected: