Actual source code: Sieve.hh

  2: #ifndef included_ALE_Sieve_hh
  3: #define included_ALE_Sieve_hh

  5: #ifndef  included_ALE_PreSieve_hh
  6: #include <PreSieve.hh>
  7: #endif

  9: namespace ALE {


 12:   class Sieve : public PreSieve {
 13:   public:
 14:     typedef enum {additionPolicyAcyclic = 0, additionPolicyStratified} AdditionPolicy;
 15:     typedef enum {stratificationPolicyOnLocking = 0, stratificationPolicyOnMutation} StratificationPolicy;
 16:   protected:
 17:     Point__int                   _depth;
 18:     Point__int                   _height;
 19:     inline void                  __setHeight(Point p,int32_t h);
 20:     inline void                  __setDepth(Point p,int32_t d);
 21:     void                         __computeStarDepths(Point p){
 22:       Point_set points; points.insert(p);__computeStarDepths(points);
 23:     };
 24:     void                         __computeClosureHeights(Point p){
 25:       Point_set points;points.insert(p);__computeClosureHeights(points);
 26:     };
 27:     void                         __computeStarDepths(Obj<Point_set> points);
 28:     void                         __computeClosureHeights(Obj<Point_set> points);
 29:     AdditionPolicy               _additionPolicy;
 30:     StratificationPolicy         _stratificationPolicy;
 31:   public:
 32:     Sieve();
 33:     Sieve(MPI_Comm comm);
 34:     virtual                   ~Sieve();
 35:     virtual void              setComm(MPI_Comm comm);
 36:     virtual Sieve&            clear();
 37:     virtual Sieve&            getLock();
 38:     //----------------------------------------------------------------------
 39:     Sieve&                    setAdditionPolicy(AdditionPolicy policy);
 40:     AdditionPolicy            getAdditionPolicy();
 41:     Sieve&                    setStratificationPolicy(StratificationPolicy policy);
 42:     StratificationPolicy      getStratificationPolicy();
 43:     virtual Sieve&            addArrow(const Point& i, const Point& j);
 44:     virtual Sieve&            removeArrow(const Point& i, const Point& j, bool removeSingleton = false);
 45:     virtual Sieve&            addBasePoint(const Point& p);
 46:     virtual Sieve&            removeBasePoint(const Point& p, bool removeSingleton = false);
 47:     virtual Sieve&            addCapPoint(const Point& q);
 48:     virtual Sieve&            removeCapPoint(const Point& q, bool removeSingleton = false);
 49:     virtual Obj<Point_set>    closure(const Point& p){return this->closure(Obj<Point_set>(Point_set(p)));};
 50:     virtual Obj<Point_set>    closure(Obj<Point_set> chain);
 51:     virtual Obj<Sieve>        closureSieve(Obj<Point_set> chain, Obj<Sieve> closure = Obj<Sieve>());
 52:     virtual Point_set         star(Point p){Point_set pSet(p); return star(pSet);};
 53:     virtual Point_set         star(Point_set& chain);
 54:     virtual Obj<Sieve>        starSieve(Obj<Point_set> chain, Obj<Sieve> star = Obj<Sieve>());
 55:     virtual Point_set         meet(Point_set c1, Point_set c2);
 56:     virtual Point_set         meet(Point& p1, Point& p2){
 57:       Point_set p1Set(p1), p2Set(p2); return this->meet(p1Set, p2Set);
 58:     };
 59:     virtual Point_set         meetAll(Point_set& chain);
 60:     virtual Point_set         join(Point_set c1, Point_set c2);
 61:     virtual Point_set         join(Point& p1, Point& p2){
 62:       Point_set p1Set(p1), p2Set(p2); return this->join(p1Set, p2Set);
 63:     };
 64:     Point_set                 joinAll(Point_set& chain);
 65:     virtual Point_set         roots(){return this->_roots;};
 66:     virtual Point_set         leaves(){return this->_leaves;};
 67:     virtual Point_set         roots(Point_set chain);
 68:     virtual Point_set         roots(Point point){Point_set pSet; pSet.insert(point); return this->roots(pSet);};
 69:     virtual Point_set         leaves(Point_set chain);
 70:     virtual Point_set         leaves(Point point){Point_set pSet; pSet.insert(point); return this->leaves(pSet);};
 71:     virtual int32_t           depth(const Point& p);
 72:     virtual int32_t           height(Point p);
 73:     virtual int32_t           maxDepth(Point_set &points);
 74:     virtual int32_t           maxDepth(Obj<Point_set> points);
 75:     virtual int32_t           maxHeight(Point_set &points);
 76:     virtual int32_t           maxHeight(Obj<Point_set> points);
 77:     virtual int32_t           diameter(Point p);
 78:     virtual int32_t           diameter();
 79:     virtual Point_set         depthStratum(int32_t depth);
 80:     virtual Point_set         heightStratum(int32_t height);
 81:     void                      view(const char *name);
 82:     // Overloading methods to ensure the correct return type
 83:     Sieve*                    baseRestriction(Point_set& base);
 84:     Sieve*                    capRestriction(Point_set& cap);

 86:   };

 88: 
 89: } // namespace ALE

 91: #endif