SolveSpaceSolver_Storage.h

// Copyright (C) 2014-2023  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 SolveSpaceSolver_Storage_H_
#define SolveSpaceSolver_Storage_H_
 
#include <SketchSolver_Storage.h>
#include <SolveSpaceSolver_Solver.h>
 
#include <list>
#include <memory>
#include <set>
#include <vector>
 
typedef std::list< std::set<ConstraintWrapperPtr> >             SameConstraintMap;
 
class SolveSpaceSolver_Storage : public SketchSolver_Storage
{
public:
  SolveSpaceSolver_Storage(const GroupID& theGroup);
 
// =============   Inherited from SketchSolver_Storage   =============
 
  virtual bool update(ConstraintWrapperPtr theConstraint);
  virtual bool update(EntityWrapperPtr theEntity);
  virtual bool update(ParameterWrapperPtr theParameter);
 
  virtual void refresh(bool theFixedOnly = false) const;
 
  virtual void verifyFixed();
 
  virtual void addCoincidentPoints(EntityWrapperPtr theMaster, EntityWrapperPtr theSlave);
 
  virtual EntityWrapperPtr calculateMiddlePoint(EntityWrapperPtr theBase, double theCoeff);
 
protected:
  virtual bool remove(ConstraintWrapperPtr theConstraint);
  virtual bool remove(EntityWrapperPtr theEntity);
  virtual bool remove(ParameterWrapperPtr theParameter);
 
  virtual void changeGroup(EntityWrapperPtr theEntity, const GroupID& theGroup);
  virtual void changeGroup(ParameterWrapperPtr theParam, const GroupID& theGroup);
 
 
// =============   Own methods   =============
public:
  void storeWorkplane(EntityWrapperPtr theSketch);
 
  Slvs_hParam addParameter(const Slvs_Param& theParam);
  Slvs_hParam updateParameter(const Slvs_Param& theParam);
  bool removeParameter(const Slvs_hParam& theParamID);
  const Slvs_Param& getParameter(const Slvs_hParam& theParamID) const;
 
  Slvs_hEntity addEntity(const Slvs_Entity& theEntity);
  Slvs_hEntity updateEntity(const Slvs_Entity& theEntity);
  bool removeEntity(const Slvs_hEntity& theEntityID);
  const Slvs_Entity& getEntity(const Slvs_hEntity& theEntityID) const;
  const Slvs_hEntity& entityMaxID() const
  { return myEntityMaxID; }
 
  Slvs_hConstraint addConstraint(const Slvs_Constraint& theConstraint);
  Slvs_hConstraint updateConstraint(const Slvs_Constraint& theConstraint);
  bool removeConstraint(const Slvs_hConstraint& theConstraintID);
  const Slvs_Constraint& getConstraint(const Slvs_hConstraint& theConstraintID) const;
  size_t nbConstraints() const
  { return myConstraints.size(); }
 
  virtual bool hasDuplicatedConstraint() const
  { return myDuplicatedConstraint; }
 
  virtual void initializeSolver(SolverPtr theSolver);
 
private:
  void adjustArc(const Slvs_Entity& theArc);
 
  void replaceInFeatures(EntityWrapperPtr theSource, EntityWrapperPtr theDest);
  void replaceInConstraints(EntityWrapperPtr theSource, EntityWrapperPtr theDest);
 
  void addSameConstraints(ConstraintWrapperPtr theConstraint1,
                          ConstraintWrapperPtr theConstraint2);
 
  bool findSameConstraint(ConstraintWrapperPtr theConstraint);
 
private:
  Slvs_hEntity myWorkplaneID; 
 
  Slvs_hParam myParamMaxID;
 
  std::vector<Slvs_Param> myParameters;
  Slvs_hEntity myEntityMaxID; 
 
  std::vector<Slvs_Entity> myEntities;
 
  Slvs_hConstraint myConstrMaxID;
 
  std::vector<Slvs_Constraint> myConstraints;
 
  bool myDuplicatedConstraint; 
 
  SameConstraintMap myEqualConstraints; 
};
 
#endif