src/SketchSolver/SketchSolver_Manager.h

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:    SketchSolver_Manager.h
   4 // Created: 08 May 2014
   5 // Author:  Artem ZHIDKOV
   6
   7 #ifndef SketchSolver_Manager_H_
   8 #define SketchSolver_Manager_H_
   9
  10 #include "SketchSolver.h"
  11 #include <SketchSolver_Group.h>
  12 #include <SketchSolver_Builder.h>
  13
  14 #include <Events_Listener.h>
  15 #include <SketchPlugin_Constraint.h>
  16
  17 #include <list>
  18 #include <set>
  19
  20 /** \class   SketchSolver_Manager
  21  *  \ingroup Plugins
  22  *  \brief   Listens the changes of SketchPlugin features and transforms the Constraint
  23  *           feature into the format understandable by SolveSpace library.
  24  *
  25  *  Constraints created for SolveSpace library are divided into the groups.
  26  *  The division order based on connectedness of the features by the constraints.
  27  *  The groups may be fused or separated according to the new constraints.
  28  *
  29  *  \remark This is a singleton.
  30  */
  31 class SketchSolver_Manager : public Events_Listener
  32 {
  33 public:
  34   /** \brief Main method to create constraint manager
  35    *  \return pointer to the singleton
  36    */
  37   SKETCHSOLVER_EXPORT static SketchSolver_Manager* instance();
  38
  39   /** \brief Implementation of Event Listener method
  40    *  \param[in] theMessage the data of the event
  41    */
  42   virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
  43
  44   /**
  45    * The solver needs all the updated objects are transfered in one group, not one by one.
  46    * This iscreases performance and avoids problems in resolve of only part of the made updates.
  47    */
  48   virtual bool groupMessages();
  49
  50   /// \brief Initialize builder for solver's data structure entities
  51   /// \param theBuilder [in]  solver's specific builder
  52   SKETCHSOLVER_EXPORT void setBuilder(BuilderPtr theBuilder);
  53   /// \brief Returns the builder specific for the solver
  54   BuilderPtr builder();
  55
  56 protected:
  57   SketchSolver_Manager();
  58   ~SketchSolver_Manager();
  59
  60   /** \brief Adds or updates a constraint or an entity in the suitable group
  61    *  \param[in] theFeature sketch feature to be changed
  62    *  \return \c true if the feature changed successfully
  63    */
  64   bool changeFeature(std::shared_ptr<SketchPlugin_Feature> theFeature);
  65
  66   /** \brief Removes a constraint from the manager
  67    *  \param[in] theConstraint constraint to be removed
  68    *  \return \c true if the constraint removed successfully
  69    */
  70   bool removeConstraint(std::shared_ptr<SketchPlugin_Constraint> theConstraint);
  71
  72   /** \brief Adds or updates a workplane in the manager
  73    *  \param[in] theSketch the feature to create or update workplane
  74    *  \return \c true if the workplane changed successfully
  75    *  \remark Type of theSketch is not verified inside
  76    */
  77   bool changeWorkplane(CompositeFeaturePtr theSketch);
  78
  79   /** \brief Removes a workplane from the manager.
  80    *         All groups based on such workplane will be removed too.
  81    *  \param[in] theSketch the feature to be removed
  82    *  \return \c true if the workplane removed successfully
  83    */
  84   bool removeWorkplane(std::shared_ptr<SketchPlugin_Sketch> theSketch);
  85
  86   /** \brief Updates entity which is moved in GUI
  87    *  \param[in] theFeature entity to be updated
  88    *  \return \c true, if the entity has been moved
  89    */
  90   bool moveEntity(std::shared_ptr<SketchPlugin_Feature> theFeature);
  91
  92   /** \brief Goes through the list of groups and solve the constraints
  93    *  \param[in] theGroups  list of groups to be resolved (if empty list, all groups are resolved)
  94    *  \return \c true, if groups are resolved, and features should be updated (send the Update event)
  95    */
  96   bool resolveConstraints(const std::list<SketchSolver_Group*>& theGroups = std::list<SketchSolver_Group*>());
  97
  98 private:
  99   /** \brief Searches list of groups which interact with specified feature
 100    *  \param[in]  theFeature  object to be found
 101    *  \param[out] theGroups   list of group indexes interacted with the feature
 102    */
 103   void findGroups(std::shared_ptr<SketchPlugin_Feature> theFeature,
 104                   std::set<GroupID>& theGroupIDs) const;
 105
 106   /** \brief Searches in the list of groups the workplane which contains specified feature
 107    *  \param[in] theFeature object to be found
 108    *  \return workplane containing the feature
 109    */
 110   std::shared_ptr<ModelAPI_CompositeFeature> findWorkplane(
 111       std::shared_ptr<SketchPlugin_Feature> theFeature) const;
 112
 113   /// \brief Stop sending the Update event until all features updated
 114   /// \return \c true, if the last flushed event is Update
 115   bool stopSendUpdate() const;
 116   /// \brief Allow to send the Update event
 117   void allowSendUpdate() const;
 118
 119   /// \brief If the message shows that any group is repaired after conflicting,
 120   ///        find other groups on the same sketch, which have conflicts.
 121   void checkConflictingConstraints(const std::shared_ptr<Events_Message>& theMessage);
 122
 123   /// \brief Calculate DoF for each sketch and send messages if changed
 124   void degreesOfFreedom();
 125
 126 private:
 127   static SketchSolver_Manager*     mySelf;    ///< Self pointer to implement singleton functionality
 128   std::list<SketchSolver_Group*>   myGroups;  ///< Groups of constraints
 129   BuilderPtr                       myBuilder; ///< Builder for solver's entities
 130   /// true if computation is performed and all "updates" are generated by this algo
 131   /// and needs no recomputation
 132   bool myIsComputed;
 133
 134   std::map<CompositeFeaturePtr, int> myDoF; ///< Degree of freedom for corresponding sketch
 135 };
 136
 137 #endif