SketchSolver_Storage.h

// Copyright (C) 2014-2026  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef SketchSolver_Storage_H_
#define SketchSolver_Storage_H_
 
#include <PlaneGCSSolver_ConstraintWrapper.h>
#include <PlaneGCSSolver_EntityWrapper.h>
 
#include <PlaneGCSSolver_Solver.h>
#include <PlaneGCSSolver_UpdateFeature.h>
 
#include <ModelAPI_Attribute.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_Feature.h>
#include <SketchPlugin_Constraint.h>
 
class SketchSolver_ConstraintDistance;
class SketchSolver_ConstraintFixedArcRadius;
typedef std::map<EntityWrapperPtr, std::set<EntityWrapperPtr> > CoincidentPointsMap;
 
 
class SketchSolver_Storage
{
private:
  SketchSolver_Storage(const SketchSolver_Storage&);
  SketchSolver_Storage& operator=(const SketchSolver_Storage&);
 
public:
  SketchSolver_Storage(SolverPtr theSolver);
 
  virtual void addConstraint(ConstraintPtr        theConstraint,
                             ConstraintWrapperPtr theSolverConstraint);
 
  virtual void addMovementConstraint(const ConstraintWrapperPtr& theSolverConstraint) = 0;
 
  void addEntity(FeaturePtr       theFeature,
                 EntityWrapperPtr theSolverEntity);
 
  void addEntity(AttributePtr     theAttribute,
                 EntityWrapperPtr theSolverEntity);
 
  virtual bool update(FeaturePtr theFeature, bool theForce = false) = 0;
 
  virtual bool update(AttributePtr theAttribute, bool theForce = false) = 0;
 
  const ConstraintWrapperPtr& constraint(const ConstraintPtr& theConstraint) const;
 
  const EntityWrapperPtr& entity(const FeaturePtr& theFeature) const;
  const EntityWrapperPtr& entity(const AttributePtr& theAttribute) const;
 
  virtual void makeExternal(const EntityWrapperPtr& theEntity) = 0;
  virtual void makeNonExternal(const EntityWrapperPtr& theEntity) = 0;
 
  virtual bool removeConstraint(ConstraintPtr theConstraint) = 0;
 
  virtual bool changeActiveStatus(ConstraintPtr theConstraint, bool theNewState) = 0;
 
  virtual bool UpdateDeactivateList() = 0;
 
  void removeFeature(FeaturePtr theFeature);
  void removeAttribute(AttributePtr theAttribute);
 
  virtual void removeInvalidEntities() = 0;
 
  bool areFeaturesValid() const;
 
  virtual bool isEmpty() const
  { return myConstraintMap.empty(); }
 
  virtual bool isNeedToResolve()
  { return myNeedToResolve; }
  void setNeedToResolve(bool theFlag)
  { myNeedToResolve = theFlag; }
 
  std::set<ObjectPtr> getConflictingConstraints(SolverPtr theSolver) const;
 
  virtual void getUnderconstrainedGeometry(std::set<ObjectPtr>& theFeatures) const = 0;
 
  virtual PlaneGCSSolver_Solver::SolveStatus checkDegeneratedGeometry() const = 0;
 
  virtual void refresh() const = 0;
 
  void blockEvents(bool isBlocked);
 
  void subscribeUpdates(SketchSolver_Constraint* theSubscriber, const std::string& theGroup) const;
  void unsubscribeUpdates(SketchSolver_Constraint* theSubscriber) const;
 
  void notify(const FeaturePtr& theFeature) const;
 
  virtual void adjustParametrizationOfArcs() = 0;
 
protected:
  static void resultToFeatureOrAttribute(const ObjectPtr& theResult,
                                         FeaturePtr&      theFeature,
                                         AttributePtr&    theAttribute);
 
protected:
  SolverPtr mySketchSolver; 
  bool    myNeedToResolve; 
  bool    myEventsBlocked; 
 
  std::map<ConstraintPtr, ConstraintWrapperPtr> myConstraintMap;
  std::map<FeaturePtr, EntityWrapperPtr>        myFeatureMap;
  std::map<AttributePtr, EntityWrapperPtr>      myAttributeMap;
 
  UpdaterPtr myUpdaters;
  std::map<ConstraintPtr, ConstraintWrapperPtr> myDeactivatedConstraintMap;
};
 
typedef std::shared_ptr<SketchSolver_Storage> StoragePtr;
 
#endif