]> SALOME platform Git repositories - tools/medcoupling.git/commitdiff
Salome HOME
Unwarningization under Win.
authorageay <ageay>
Thu, 22 Aug 2013 14:57:38 +0000 (14:57 +0000)
committerageay <ageay>
Thu, 22 Aug 2013 14:57:38 +0000 (14:57 +0000)
src/INTERP_KERNEL/ExprEval/InterpKernelExprParser.hxx
src/INTERP_KERNEL/ExprEval/InterpKernelUnit.hxx
src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DAbstractEdge.hxx
src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DComposedEdge.hxx
src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DQuadraticPolygon.hxx
src/MEDCoupling/MEDCoupling1GTUMesh.cxx

index 1e671ad917fa4be1091bb81216079fae982b92b2..1d7df48b9b14ece84e6d3b5b9e8aae8bd7e7f63d 100644 (file)
@@ -79,30 +79,30 @@ namespace INTERP_KERNEL
     std::string _var_name;
   };
 
-  class INTERPKERNEL_EXPORT ExprParser
+  class ExprParser
   {
   public:
-    ExprParser(const char *expr, ExprParser *father=0);
-    ExprParser(const char *expr, int lgth, ExprParser *father=0);
-    ~ExprParser();
-    void parse() throw(INTERP_KERNEL::Exception);
-    bool isParsingSuccessfull() const { return _is_parsing_ok; }
-    double evaluate() const throw(INTERP_KERNEL::Exception);
-    DecompositionInUnitBase evaluateUnit() const throw(INTERP_KERNEL::Exception);
-    void prepareExprEvaluation(const std::vector<std::string>& vars, int nbOfCompo, int targetNbOfCompo) const throw(INTERP_KERNEL::Exception);
-    void evaluateExpr(int szOfOutParam, const double *inParam, double *outParam) const throw(INTERP_KERNEL::Exception);
-    void prepareExprEvaluationVec() const throw(INTERP_KERNEL::Exception);
-    void getSetOfVars(std::set<std::string>& vars) const;
-    void getTrueSetOfVars(std::set<std::string>& vars) const;
+    INTERPKERNEL_EXPORT ExprParser(const char *expr, ExprParser *father=0);
+    INTERPKERNEL_EXPORT ExprParser(const char *expr, int lgth, ExprParser *father=0);
+    INTERPKERNEL_EXPORT ~ExprParser();
+    INTERPKERNEL_EXPORT void parse() throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT bool isParsingSuccessfull() const { return _is_parsing_ok; }
+    INTERPKERNEL_EXPORT double evaluate() const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT DecompositionInUnitBase evaluateUnit() const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT void prepareExprEvaluation(const std::vector<std::string>& vars, int nbOfCompo, int targetNbOfCompo) const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT void evaluateExpr(int szOfOutParam, const double *inParam, double *outParam) const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT void prepareExprEvaluationVec() const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT void getSetOfVars(std::set<std::string>& vars) const;
+    INTERPKERNEL_EXPORT void getTrueSetOfVars(std::set<std::string>& vars) const;
     //
-    char *compileX86() const;
-    char *compileX86_64() const;
-    void compileX86LowLev(std::vector<std::string>& ass) const;
-    void compileX86_64LowLev(std::vector<std::string>& ass) const;
-    int getStackSizeToPlayX86(const ExprParser *asker) const;
+    INTERPKERNEL_EXPORT char *compileX86() const;
+    INTERPKERNEL_EXPORT char *compileX86_64() const;
+    INTERPKERNEL_EXPORT void compileX86LowLev(std::vector<std::string>& ass) const;
+    INTERPKERNEL_EXPORT void compileX86_64LowLev(std::vector<std::string>& ass) const;
+    INTERPKERNEL_EXPORT int getStackSizeToPlayX86(const ExprParser *asker) const;
     //
-    static std::string buildStringFromFortran(const char *expr, int lgth);
-    static std::string deleteWhiteSpaces(const std::string& expr);
+    INTERPKERNEL_EXPORT static std::string buildStringFromFortran(const char *expr, int lgth);
+    INTERPKERNEL_EXPORT static std::string deleteWhiteSpaces(const std::string& expr);
   private:
     Value *evaluateLowLev(Value *valGen) const throw(INTERP_KERNEL::Exception);
   private:
index ff4c9d9ab51cc71a272dabf702e7571e3cf6c344..c6d49935c8c816f108affc1a2e48eb162fbc42d4 100644 (file)
 
 namespace INTERP_KERNEL
 {
-  class INTERPKERNEL_EXPORT UnitDataBase
+  class UnitDataBase
   {
   public:
-    UnitDataBase();
-    const short *getInfoForUnit(const std::string& unit,
-                                double& addFact, double& mFact) const throw(INTERP_KERNEL::Exception);
-    static UnitDataBase _uniqueMapForExpr;
-    static const int SIZE_OF_UNIT_BASE=5;
+    INTERPKERNEL_EXPORT UnitDataBase();
+    INTERPKERNEL_EXPORT const short *getInfoForUnit(const std::string& unit,
+                                                    double& addFact, double& mFact) const throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT static UnitDataBase _uniqueMapForExpr;
+    INTERPKERNEL_EXPORT static const int SIZE_OF_UNIT_BASE=5;
   private:
     std::map<std::string,double> _prefix_pow_10;
     std::map<std::string,const short *> _units_semantic;
@@ -53,24 +53,24 @@ namespace INTERP_KERNEL
     static const double ADD_COEFF[NB_OF_UNITS_RECOGN];
   };
 
-  class INTERPKERNEL_EXPORT DecompositionInUnitBase
+  class DecompositionInUnitBase
   {
   public:
-    DecompositionInUnitBase();
-    void setInfo(const short *vals, double addFact, double mFact);
-    short operator[](int i) const { return _value[i]; }
-    bool operator==(const DecompositionInUnitBase& other) const;
-    void getTranslationParams(const DecompositionInUnitBase& other, double& mul, double& add) const;
-    bool isEqual(short mass, short lgth, short time, short intensity, short temp,
-                 double add, double mult);
-    bool isUnitary() const;
+    INTERPKERNEL_EXPORT DecompositionInUnitBase();
+    INTERPKERNEL_EXPORT void setInfo(const short *vals, double addFact, double mFact);
+    INTERPKERNEL_EXPORT short operator[](int i) const { return _value[i]; }
+    INTERPKERNEL_EXPORT bool operator==(const DecompositionInUnitBase& other) const;
+    INTERPKERNEL_EXPORT void getTranslationParams(const DecompositionInUnitBase& other, double& mul, double& add) const;
+    INTERPKERNEL_EXPORT bool isEqual(short mass, short lgth, short time, short intensity, short temp,
+                                     double add, double mult);
+    INTERPKERNEL_EXPORT bool isUnitary() const;
     //! \b WARNING no test is done on the fact that unit is adimensionnal.
-    void negate();
-    bool isAdimensional() const;
-    void tryToConvertInUnit(double val) throw(INTERP_KERNEL::Exception);
-    DecompositionInUnitBase &operator*(const DecompositionInUnitBase& other);
-    DecompositionInUnitBase &operator/(const DecompositionInUnitBase& other);
-    DecompositionInUnitBase &operator^(const DecompositionInUnitBase& other) throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT void negate();
+    INTERPKERNEL_EXPORT bool isAdimensional() const;
+    INTERPKERNEL_EXPORT void tryToConvertInUnit(double val) throw(INTERP_KERNEL::Exception);
+    INTERPKERNEL_EXPORT DecompositionInUnitBase &operator*(const DecompositionInUnitBase& other);
+    INTERPKERNEL_EXPORT DecompositionInUnitBase &operator/(const DecompositionInUnitBase& other);
+    INTERPKERNEL_EXPORT DecompositionInUnitBase &operator^(const DecompositionInUnitBase& other) throw(INTERP_KERNEL::Exception);
   private:
     void dealWithAddFactor(const DecompositionInUnitBase& other);
     static int couldItBeConsideredAsInt(double val) throw(INTERP_KERNEL::Exception);
@@ -97,16 +97,16 @@ namespace INTERP_KERNEL
    * dimension 3 stands for elec intensity A.
    * dimension 4 stands for temperature in K.
    */
-  class INTERPKERNEL_EXPORT Unit
+  class Unit
   {
   public:
-    Unit(const char *reprC, bool tryToInterp=true);
-    Unit(const char *reprFortran, int sizeOfRepr, bool tryToInterp=true);
-    void tryToInterprate() const;
-    bool isInterpretationOK() const;
-    bool isCompatibleWith(const Unit& other) const;
-    double convert(const Unit& target, double sourceVal) const;
-    std::string getCoarseRepr() const;
+    INTERPKERNEL_EXPORT Unit(const char *reprC, bool tryToInterp=true);
+    INTERPKERNEL_EXPORT Unit(const char *reprFortran, int sizeOfRepr, bool tryToInterp=true);
+    INTERPKERNEL_EXPORT void tryToInterprate() const;
+    INTERPKERNEL_EXPORT bool isInterpretationOK() const;
+    INTERPKERNEL_EXPORT bool isCompatibleWith(const Unit& other) const;
+    INTERPKERNEL_EXPORT double convert(const Unit& target, double sourceVal) const;
+    INTERPKERNEL_EXPORT std::string getCoarseRepr() const;
   private:
     std::string _coarse_repr;
     mutable bool _is_interpreted;
index 8d580a936a6ca09ff2aff33bd7c37751e1a8eff1..f8144da85439452fe99f6eabc6bbd6d5de35d2ff 100644 (file)
@@ -39,26 +39,26 @@ namespace INTERP_KERNEL
   /*!
    * Asumption is done with this iterator that we iterate on a container containing more than one edge.
    */
-  class INTERPKERNEL_EXPORT IteratorOnComposedEdge
+  class IteratorOnComposedEdge
   {
     friend class ComposedEdge;
     friend class ElementaryEdge;
     friend class QuadraticPolygon;
   public:
-    IteratorOnComposedEdge();
-    IteratorOnComposedEdge(ComposedEdge *compEdges);
-    bool isValid() const { return _list_handle!=0; } 
-    void operator=(const IteratorOnComposedEdge& other);
-    void first() { _deep_it=_list_handle->begin(); }
-    void next() { _deep_it++; }
-    void last();
-    void nextLoop();
-    void previousLoop();
-    bool finished() const { return _deep_it==_list_handle->end(); }
-    bool goToNextInOn(bool direction, int& i, int nbMax);
-    ElementaryEdge *current() { return *_deep_it; }
-    void assignMySelfToAllElems(ComposedEdge *elems);
-    void insertElemEdges(ComposedEdge *elems, bool changeMySelf);
+    INTERPKERNEL_EXPORT IteratorOnComposedEdge();
+    INTERPKERNEL_EXPORT IteratorOnComposedEdge(ComposedEdge *compEdges);
+    INTERPKERNEL_EXPORT bool isValid() const { return _list_handle!=0; } 
+    INTERPKERNEL_EXPORT void operator=(const IteratorOnComposedEdge& other);
+    INTERPKERNEL_EXPORT void first() { _deep_it=_list_handle->begin(); }
+    INTERPKERNEL_EXPORT void next() { _deep_it++; }
+    INTERPKERNEL_EXPORT void last();
+    INTERPKERNEL_EXPORT void nextLoop();
+    INTERPKERNEL_EXPORT void previousLoop();
+    INTERPKERNEL_EXPORT bool finished() const { return _deep_it==_list_handle->end(); }
+    INTERPKERNEL_EXPORT bool goToNextInOn(bool direction, int& i, int nbMax);
+    INTERPKERNEL_EXPORT ElementaryEdge *current() { return *_deep_it; }
+    INTERPKERNEL_EXPORT void assignMySelfToAllElems(ComposedEdge *elems);
+    INTERPKERNEL_EXPORT void insertElemEdges(ComposedEdge *elems, bool changeMySelf);
   private:
     std::list<ElementaryEdge *>::iterator _deep_it;
     std::list<ElementaryEdge *>* _list_handle;
index 9c3cd74ca2fc0679775f03282909cada92f7caeb..206a7017ed68070d3ae21562159f6909baf4c01b 100644 (file)
@@ -36,61 +36,61 @@ namespace INTERP_KERNEL
   class ElementaryEdge;
   class IteratorOnComposedEdge;
 
-  class INTERPKERNEL_EXPORT ComposedEdge
+  class ComposedEdge
   {
     friend class IteratorOnComposedEdge;
   public:
-    ComposedEdge() { }
-    ComposedEdge(const ComposedEdge& other);
-    ComposedEdge(int sz):_sub_edges(sz) { }
-    static void Delete(ComposedEdge *pt) { delete pt; }
-    static void SoftDelete(ComposedEdge *pt) { pt->_sub_edges.clear(); delete pt; }
-    void reverse();
-    int recursiveSize() const { return (int)_sub_edges.size(); }
-    bool presenceOfOn() const;
-    bool presenceOfQuadraticEdge() const;
-    void initLocations() const;
-    void initLocationsWithOther(const ComposedEdge& other) const;
-    ComposedEdge *clone() const;
-    bool isNodeIn(Node *n) const;
-    double getArea() const;
-    double getPerimeter() const;
-    double getHydraulicDiameter() const;
-    void getBarycenter(double *bary) const;
-    void getBarycenterGeneral(double *bary) const;
-    double normalize(ComposedEdge *other, double& xBary, double& yBary);
-    double normalizeExt(ComposedEdge *other, double& xBary, double& yBary);
-    void unApplyGlobalSimilarityExt(ComposedEdge& other, double xBary, double yBary, double fact);
-    void fillBounds(Bounds& output) const;
-    void applySimilarity(double xBary, double yBary, double dimChar);
-    void applyGlobalSimilarity(double xBary, double yBary, double dimChar);
-    void applyGlobalSimilarity2(ComposedEdge *other, double xBary, double yBary, double dimChar);
-    void dispatchPerimeter(double& partConsidered) const;
-    void dispatchPerimeterExcl(double& partConsidered, double& commonPart) const;
-    double dispatchPerimeterAdv(const ComposedEdge& father, std::vector<double>& result) const;
-    void getAllNodes(std::set<Node *>& output) const;
-    void getBarycenter(double *bary, double& weigh) const;
-    bool completed() const { return getEndNode()==getStartNode(); }
-    void setValueAt(int i, Edge *e, bool direction=true);
-    double getCommonLengthWith(const ComposedEdge& other) const;
-    void clear();
-    bool empty() const { return _sub_edges.empty(); }
-    ElementaryEdge *front() const { return _sub_edges.front(); }
-    ElementaryEdge *back() const { return _sub_edges.back(); }
-    void resize(int i) { _sub_edges.resize(i); }
-    void pushBack(Edge *edge, bool direction=true);
-    void pushBack(ElementaryEdge *elem);
-    void pushBack(ComposedEdge *elem);
-    int size() const { return (int)_sub_edges.size(); }
-    ElementaryEdge *operator[](int i) const;
-    Node *getEndNode() const;
-    Node *getStartNode() const;
-    bool changeEndNodeWith(Node *node) const;
-    bool changeStartNodeWith(Node *node) const;
-    void dumpInXfigFile(std::ostream& stream, int resolution, const Bounds& box) const;
-    bool isInOrOut(Node *nodeToTest) const;
-    bool getDirection() const;
-    bool intresincEqCoarse(const Edge *other) const;
+    INTERPKERNEL_EXPORT ComposedEdge() { }
+    INTERPKERNEL_EXPORT ComposedEdge(const ComposedEdge& other);
+    INTERPKERNEL_EXPORT ComposedEdge(int sz):_sub_edges(sz) { }
+    INTERPKERNEL_EXPORT static void Delete(ComposedEdge *pt) { delete pt; }
+    INTERPKERNEL_EXPORT static void SoftDelete(ComposedEdge *pt) { pt->_sub_edges.clear(); delete pt; }
+    INTERPKERNEL_EXPORT void reverse();
+    INTERPKERNEL_EXPORT int recursiveSize() const { return (int)_sub_edges.size(); }
+    INTERPKERNEL_EXPORT bool presenceOfOn() const;
+    INTERPKERNEL_EXPORT bool presenceOfQuadraticEdge() const;
+    INTERPKERNEL_EXPORT void initLocations() const;
+    INTERPKERNEL_EXPORT void initLocationsWithOther(const ComposedEdge& other) const;
+    INTERPKERNEL_EXPORT ComposedEdge *clone() const;
+    INTERPKERNEL_EXPORT bool isNodeIn(Node *n) const;
+    INTERPKERNEL_EXPORT double getArea() const;
+    INTERPKERNEL_EXPORT double getPerimeter() const;
+    INTERPKERNEL_EXPORT double getHydraulicDiameter() const;
+    INTERPKERNEL_EXPORT void getBarycenter(double *bary) const;
+    INTERPKERNEL_EXPORT void getBarycenterGeneral(double *bary) const;
+    INTERPKERNEL_EXPORT double normalize(ComposedEdge *other, double& xBary, double& yBary);
+    INTERPKERNEL_EXPORT double normalizeExt(ComposedEdge *other, double& xBary, double& yBary);
+    INTERPKERNEL_EXPORT void unApplyGlobalSimilarityExt(ComposedEdge& other, double xBary, double yBary, double fact);
+    INTERPKERNEL_EXPORT void fillBounds(Bounds& output) const;
+    INTERPKERNEL_EXPORT void applySimilarity(double xBary, double yBary, double dimChar);
+    INTERPKERNEL_EXPORT void applyGlobalSimilarity(double xBary, double yBary, double dimChar);
+    INTERPKERNEL_EXPORT void applyGlobalSimilarity2(ComposedEdge *other, double xBary, double yBary, double dimChar);
+    INTERPKERNEL_EXPORT void dispatchPerimeter(double& partConsidered) const;
+    INTERPKERNEL_EXPORT void dispatchPerimeterExcl(double& partConsidered, double& commonPart) const;
+    INTERPKERNEL_EXPORT double dispatchPerimeterAdv(const ComposedEdge& father, std::vector<double>& result) const;
+    INTERPKERNEL_EXPORT void getAllNodes(std::set<Node *>& output) const;
+    INTERPKERNEL_EXPORT void getBarycenter(double *bary, double& weigh) const;
+    INTERPKERNEL_EXPORT bool completed() const { return getEndNode()==getStartNode(); }
+    INTERPKERNEL_EXPORT void setValueAt(int i, Edge *e, bool direction=true);
+    INTERPKERNEL_EXPORT double getCommonLengthWith(const ComposedEdge& other) const;
+    INTERPKERNEL_EXPORT void clear();
+    INTERPKERNEL_EXPORT bool empty() const { return _sub_edges.empty(); }
+    INTERPKERNEL_EXPORT ElementaryEdge *front() const { return _sub_edges.front(); }
+    INTERPKERNEL_EXPORT ElementaryEdge *back() const { return _sub_edges.back(); }
+    INTERPKERNEL_EXPORT void resize(int i) { _sub_edges.resize(i); }
+    INTERPKERNEL_EXPORT void pushBack(Edge *edge, bool direction=true);
+    INTERPKERNEL_EXPORT void pushBack(ElementaryEdge *elem);
+    INTERPKERNEL_EXPORT void pushBack(ComposedEdge *elem);
+    INTERPKERNEL_EXPORT int size() const { return (int)_sub_edges.size(); }
+    INTERPKERNEL_EXPORT ElementaryEdge *operator[](int i) const;
+    INTERPKERNEL_EXPORT Node *getEndNode() const;
+    INTERPKERNEL_EXPORT Node *getStartNode() const;
+    INTERPKERNEL_EXPORT bool changeEndNodeWith(Node *node) const;
+    INTERPKERNEL_EXPORT bool changeStartNodeWith(Node *node) const;
+    INTERPKERNEL_EXPORT void dumpInXfigFile(std::ostream& stream, int resolution, const Bounds& box) const;
+    INTERPKERNEL_EXPORT bool isInOrOut(Node *nodeToTest) const;
+    INTERPKERNEL_EXPORT bool getDirection() const;
+    INTERPKERNEL_EXPORT bool intresincEqCoarse(const Edge *other) const;
   private:
     std::list<ElementaryEdge *>* getListBehind() { return &_sub_edges; }
   protected:
index 9993fe8e2a631c24f9ff5a9d52329e110869790f..6e5db5b1f391cf3d2f24aa48297e377037f2c34f 100644 (file)
@@ -35,57 +35,57 @@ namespace INTERP_KERNEL
   class Edge;
   class MergePoints;
 
-  class INTERPKERNEL_EXPORT QuadraticPolygon : public ComposedEdge
+  class QuadraticPolygon : public ComposedEdge
   {
   public:
-    QuadraticPolygon() { }
-    QuadraticPolygon(const QuadraticPolygon& other):ComposedEdge(other) { }
-    QuadraticPolygon(const char *fileName);
-    static QuadraticPolygon *BuildLinearPolygon(std::vector<Node *>& nodes);
-    static QuadraticPolygon *BuildArcCirclePolygon(std::vector<Node *>& nodes);
-    static void BuildDbgFile(const std::vector<Node *>& nodes, const char *fileName);
-    ~QuadraticPolygon();
-    void closeMe() const;
-    void circularPermute();
-    bool isButterflyAbs();
-    bool isButterfly() const;
-    void dumpInXfigFile(const char *fileName) const;
-    void dumpInXfigFileWithOther(const ComposedEdge& other, const char *fileName) const;
+    INTERPKERNEL_EXPORT QuadraticPolygon() { }
+    INTERPKERNEL_EXPORT QuadraticPolygon(const QuadraticPolygon& other):ComposedEdge(other) { }
+    INTERPKERNEL_EXPORT QuadraticPolygon(const char *fileName);
+    INTERPKERNEL_EXPORT static QuadraticPolygon *BuildLinearPolygon(std::vector<Node *>& nodes);
+    INTERPKERNEL_EXPORT static QuadraticPolygon *BuildArcCirclePolygon(std::vector<Node *>& nodes);
+    INTERPKERNEL_EXPORT static void BuildDbgFile(const std::vector<Node *>& nodes, const char *fileName);
+    INTERPKERNEL_EXPORT ~QuadraticPolygon();
+    INTERPKERNEL_EXPORT void closeMe() const;
+    INTERPKERNEL_EXPORT void circularPermute();
+    INTERPKERNEL_EXPORT bool isButterflyAbs();
+    INTERPKERNEL_EXPORT bool isButterfly() const;
+    INTERPKERNEL_EXPORT void dumpInXfigFile(const char *fileName) const;
+    INTERPKERNEL_EXPORT void dumpInXfigFileWithOther(const ComposedEdge& other, const char *fileName) const;
     //! Before intersecting as intersectWith a normalization is done.
-    double intersectWithAbs(QuadraticPolygon& other);
-    double intersectWithAbs1D(QuadraticPolygon& other, bool& isColinear);
+    INTERPKERNEL_EXPORT double intersectWithAbs(QuadraticPolygon& other);
+    INTERPKERNEL_EXPORT double intersectWithAbs1D(QuadraticPolygon& other, bool& isColinear);
     //! Before intersecting as intersectWith a normalization is done.
-    double intersectWithAbs(QuadraticPolygon& other, double* barycenter);
-    void splitAbs(QuadraticPolygon& other, const std::map<INTERP_KERNEL::Node *,int>& mapThis, const std::map<INTERP_KERNEL::Node *,int>& mapOther, int offset1, int offset2, const std::vector<int>& otherEdgeIds,
-                  std::vector<int>& edgesThis, int cellIdThis, std::vector< std::vector<int> >& edgesInOtherColinearWithThis, std::vector< std::vector<int> >& subDivOther, std::vector<double>& addCoo);
-    void buildFromCrudeDataArray(const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords,
-                                 const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges);
-    void buildFromCrudeDataArray2(const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords, const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges,
-                                  const INTERP_KERNEL::QuadraticPolygon& pol1, const int *descBg1, const int *descEnd1, const std::vector<std::vector<int> >& intersectEdges1,
-                                  const std::vector< std::vector<int> >& colinear1,
-                                  std::map<int,std::vector<INTERP_KERNEL::ElementaryEdge *> >& alreadyExistingIn2);
-    void updateLocOfEdgeFromCrudeDataArray2(const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges, const INTERP_KERNEL::QuadraticPolygon& pol1, const int *descBg1, const int *descEnd1, const std::vector<std::vector<int> >& intersectEdges1, const std::vector< std::vector<int> >& colinear1) const;
-    void appendEdgeFromCrudeDataArray(std::size_t edgeId, const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords,
-                                      const int *descBg,  const int *descEnd, const std::vector<std::vector<int> >& intersectEdges);
-    void appendSubEdgeFromCrudeDataArray(Edge *baseEdge, std::size_t j, bool direct, int edgeId, const std::vector<int>& subEdge, const std::map<int,INTERP_KERNEL::Node *>& mapp);
-    void appendCrudeData(const std::map<INTERP_KERNEL::Node *,int>& mapp, double xBary, double yBary, double fact, int offset, std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI) const;
-    void buildPartitionsAbs(QuadraticPolygon& other, std::set<INTERP_KERNEL::Edge *>& edgesThis, std::set<INTERP_KERNEL::Edge *>& edgesBoundaryOther, const std::map<INTERP_KERNEL::Node *,int>& mapp, int idThis, int idOther, int offset,
-                            std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI, std::vector<int>& nb1, std::vector<int>& nb2);
+    INTERPKERNEL_EXPORT double intersectWithAbs(QuadraticPolygon& other, double* barycenter);
+    INTERPKERNEL_EXPORT void splitAbs(QuadraticPolygon& other, const std::map<INTERP_KERNEL::Node *,int>& mapThis, const std::map<INTERP_KERNEL::Node *,int>& mapOther, int offset1, int offset2, const std::vector<int>& otherEdgeIds,
+                                      std::vector<int>& edgesThis, int cellIdThis, std::vector< std::vector<int> >& edgesInOtherColinearWithThis, std::vector< std::vector<int> >& subDivOther, std::vector<double>& addCoo);
+    INTERPKERNEL_EXPORT void buildFromCrudeDataArray(const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords,
+                                                     const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges);
+    INTERPKERNEL_EXPORT void buildFromCrudeDataArray2(const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords, const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges,
+                                                      const INTERP_KERNEL::QuadraticPolygon& pol1, const int *descBg1, const int *descEnd1, const std::vector<std::vector<int> >& intersectEdges1,
+                                                      const std::vector< std::vector<int> >& colinear1,
+                                                      std::map<int,std::vector<INTERP_KERNEL::ElementaryEdge *> >& alreadyExistingIn2);
+    INTERPKERNEL_EXPORT void updateLocOfEdgeFromCrudeDataArray2(const int *descBg, const int *descEnd, const std::vector<std::vector<int> >& intersectEdges, const INTERP_KERNEL::QuadraticPolygon& pol1, const int *descBg1, const int *descEnd1, const std::vector<std::vector<int> >& intersectEdges1, const std::vector< std::vector<int> >& colinear1) const;
+    INTERPKERNEL_EXPORT void appendEdgeFromCrudeDataArray(std::size_t edgeId, const std::map<int,INTERP_KERNEL::Node *>& mapp, bool isQuad, const int *nodalBg, const double *coords,
+                                                          const int *descBg,  const int *descEnd, const std::vector<std::vector<int> >& intersectEdges);
+    INTERPKERNEL_EXPORT void appendSubEdgeFromCrudeDataArray(Edge *baseEdge, std::size_t j, bool direct, int edgeId, const std::vector<int>& subEdge, const std::map<int,INTERP_KERNEL::Node *>& mapp);
+    INTERPKERNEL_EXPORT void appendCrudeData(const std::map<INTERP_KERNEL::Node *,int>& mapp, double xBary, double yBary, double fact, int offset, std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI) const;
+    INTERPKERNEL_EXPORT void buildPartitionsAbs(QuadraticPolygon& other, std::set<INTERP_KERNEL::Edge *>& edgesThis, std::set<INTERP_KERNEL::Edge *>& edgesBoundaryOther, const std::map<INTERP_KERNEL::Node *,int>& mapp, int idThis, int idOther, int offset,
+                                                std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI, std::vector<int>& nb1, std::vector<int>& nb2);
     //
-    double intersectWith(const QuadraticPolygon& other) const;
-    double intersectWith(const QuadraticPolygon& other, double* barycenter) const;
-    std::vector<QuadraticPolygon *> intersectMySelfWith(const QuadraticPolygon& other) const;
-    void intersectForPerimeter(const QuadraticPolygon& other, double& perimeterThisPart, double& perimeterOtherPart, double& perimeterCommonPart) const;
-    void intersectForPerimeterAdvanced(const QuadraticPolygon& other, std::vector< double >& polThis, std::vector< double >& polOther) const;
-    void intersectForPoint(const QuadraticPolygon& other, std::vector< int >& numberOfCreatedPointsPerEdge) const;
+    INTERPKERNEL_EXPORT double intersectWith(const QuadraticPolygon& other) const;
+    INTERPKERNEL_EXPORT double intersectWith(const QuadraticPolygon& other, double* barycenter) const;
+    INTERPKERNEL_EXPORT std::vector<QuadraticPolygon *> intersectMySelfWith(const QuadraticPolygon& other) const;
+    INTERPKERNEL_EXPORT void intersectForPerimeter(const QuadraticPolygon& other, double& perimeterThisPart, double& perimeterOtherPart, double& perimeterCommonPart) const;
+    INTERPKERNEL_EXPORT void intersectForPerimeterAdvanced(const QuadraticPolygon& other, std::vector< double >& polThis, std::vector< double >& polOther) const;
+    INTERPKERNEL_EXPORT void intersectForPoint(const QuadraticPolygon& other, std::vector< int >& numberOfCreatedPointsPerEdge) const;
   public://Only public for tests reasons
-    void performLocatingOperation(QuadraticPolygon& pol2) const;
-    void performLocatingOperationSlow(QuadraticPolygon& pol2) const;
-    static void SplitPolygonsEachOther(QuadraticPolygon& pol1, QuadraticPolygon& pol2, int& nbOfSplits);
-    std::vector<QuadraticPolygon *> buildIntersectionPolygons(const QuadraticPolygon& pol1, const QuadraticPolygon& pol2) const;
-    bool amIAChanceToBeCompletedBy(const QuadraticPolygon& pol1Splitted, const QuadraticPolygon& pol2NotSplitted, bool& direction);
-    static void ComputeResidual(const QuadraticPolygon& pol1, const std::set<Edge *>& notUsedInPol1, const std::set<Edge *>& edgesInPol2OnBoundary, const std::map<INTERP_KERNEL::Node *,int>& mapp, int offset, int idThis,
-                                std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI, std::vector<int>& nb1, std::vector<int>& nb2);
+    INTERPKERNEL_EXPORT void performLocatingOperation(QuadraticPolygon& pol2) const;
+    INTERPKERNEL_EXPORT void performLocatingOperationSlow(QuadraticPolygon& pol2) const;
+    INTERPKERNEL_EXPORT static void SplitPolygonsEachOther(QuadraticPolygon& pol1, QuadraticPolygon& pol2, int& nbOfSplits);
+    INTERPKERNEL_EXPORT std::vector<QuadraticPolygon *> buildIntersectionPolygons(const QuadraticPolygon& pol1, const QuadraticPolygon& pol2) const;
+    INTERPKERNEL_EXPORT bool amIAChanceToBeCompletedBy(const QuadraticPolygon& pol1Splitted, const QuadraticPolygon& pol2NotSplitted, bool& direction);
+    INTERPKERNEL_EXPORT static void ComputeResidual(const QuadraticPolygon& pol1, const std::set<Edge *>& notUsedInPol1, const std::set<Edge *>& edgesInPol2OnBoundary, const std::map<INTERP_KERNEL::Node *,int>& mapp, int offset, int idThis,
+                                                    std::vector<double>& addCoordsQuadratic, std::vector<int>& conn, std::vector<int>& connI, std::vector<int>& nb1, std::vector<int>& nb2);
   protected:
     std::list<QuadraticPolygon *> zipConsecutiveInSegments() const;
     void dumpInXfigFile(std::ostream& stream, int resolution, const Bounds& box) const;
index 329d1b3869c2d2cc11aec8f00103c56d9ba61824..0666fe618c3eaf92c71073ba15c5626bb7b587ed 100644 (file)
@@ -2284,7 +2284,7 @@ std::string MEDCoupling1DGTUMesh::simpleRepr() const
     ret << msg0 << "\n";
   ret << "Number of cells : ";
   bool isOK=true;
-  try { checkCoherency(); } catch(INTERP_KERNEL::Exception& e)
+  try { checkCoherency(); } catch(INTERP_KERNEL::Exception& /* e */)
     {
       ret << "Nodal connectivity arrays are not set or badly set !\n";
       isOK=false;
@@ -2307,7 +2307,7 @@ std::string MEDCoupling1DGTUMesh::advancedRepr() const
   ret << "\n\nNodal Connectivity : \n____________________\n\n";
   //
   bool isOK=true;
-  try { checkCoherency1(); } catch(INTERP_KERNEL::Exception& e)
+  try { checkCoherency1(); } catch(INTERP_KERNEL::Exception& /* e */)
     {
       ret << "Nodal connectivity arrays are not set or badly set !\n";
       isOK=false;
@@ -2503,7 +2503,7 @@ void MEDCoupling1DGTUMesh::reprQuickOverview(std::ostream& stream) const throw(I
   stream << " Space dimension : " << _coords->getNumberOfComponents() << "." << std::endl;
   stream << "Number of nodes : " << _coords->getNumberOfTuples() << ".";
   bool isOK=true;
-  try { checkCoherency(); } catch(INTERP_KERNEL::Exception& e)
+  try { checkCoherency(); } catch(INTERP_KERNEL::Exception&  /* e */)
     {
       stream << std::endl << "Nodal connectivity NOT set properly !\n";
       isOK=false;