SplitData.h

Go to the documentation of this file.

#ifndef SplitData_HEADER
#define SplitData_HEADER

#include <list>
#include "RefineVertex.h"
#include <refine-common/RefineConstants.h>

/* Forward-declaration: ProtectedBall needs to know about SplitData, and
 * SplitData needs to know about ProtectedBall.  Luckily, both sides need only
 * know each others' names.  I arbitrarily chose SplitData to be the one that
 * forward-declares its partner. */
template <size_t ambient> class ProtectedBall;

/***************************************************************************
 * This is data that emerges from an insertion: the vertex inserted and the set
 * of simplices added and removed; or, if insertion yielded, the set of
 * lower-dimensional balls yielded to.
 ***************************************************************************/
template <size_t ambient>
class SplitData : public RefineConstants {
  typedef ProtectedBall<ambient> Ball;
  typedef RefineVertex<ambient> Vertex;

  Vertex *v_;
  std::list<Ball*> killed_;
  std::list<Ball*> born_;
  std::list<Ball*> encroached_;

  public:
  typedef typename std::list<Ball*>::const_iterator iterator;

  SplitData(const RefineConstants& rc): RefineConstants(rc) { }

  bool didSplit() { return v_ != 0; }

  Vertex *getVertex() const { return v_; }

  iterator begin_killed() const { return killed_.begin(); }
  iterator end_killed() const { return killed_.end(); }
  size_t nkilled() const { return killed_.size(); }

  iterator begin_born() const { return born_.begin(); }
  iterator end_born() const { return born_.end(); }
  size_t nborn() const { return born_.size(); }

  iterator begin_encroached() const { return encroached_.begin(); }
  iterator end_encroached() const { return encroached_.end(); }
  bool encroached() const { return !encroached_.empty(); }

  void setVertex(Vertex *v) { v_ = v; }
  void insertBorn(Ball *b) { born_.push_front(b); }
  void insertKill(Ball *b) { killed_.push_front(b); }
  void insertEncroached(Ball *b) { encroached_.push_front(b); }

  template <class Mesh, class simplex_iterator> void insertBorn(Mesh *mesh,
      simplex_iterator begin, const simplex_iterator& end) {
    while (begin != end) {
      Ball *b = mesh->toBall(*begin);
      insertBorn(b);
      ++begin;
    }
  }

  template <class Mesh, class simplex_iterator> void insertKill(Mesh *mesh,
      simplex_iterator begin, const simplex_iterator& end) {
    while (begin != end) {
      Ball *b = mesh->toBall(*begin);
      insertKill(b);
      ++begin;
    }
  }

  /* No equivalent insertEncroached since those are already balls. */
};

#endif

---