WorkItem.h

Go to the documentation of this file.

#ifndef WorkItem_HEADER
#define WorkItem_HEADER

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <string>
#include <utilities/SmallMemoryPool.h>
#include "MeshTypes.h"
#include "Mesh.h"
template <size_t ambient> class SplitData;

template <size_t ambient>
struct WorkItem {
  typedef ::SplitData<ambient> SplitData;
  typedef typename MeshTypes<ambient>::Ball Ball;
  typedef typename MeshTypes<ambient>::Vertex Vertex;
  typedef ::Mesh<ambient, ambient> TopMesh;

  enum Reason {
    NEW_BOUNDARY_VERTEX = 0,
    ENCROACHED,
    VERY_SKINNY,
    CROWDED_STEINER,
    CROWDED_INPUT,
    SLIVER,
    MEDIUM_SKINNY,
    UNRESOLVED,
    NONE
  };

  static string toString(Reason r) {
    switch(r) {
      case NEW_BOUNDARY_VERTEX: return "new bdry vertex";
      case ENCROACHED: return "encroached";
      case VERY_SKINNY: return "very_skinny";
      case CROWDED_STEINER: return "crowded (steiner)";
      case CROWDED_INPUT: return "crowded (input)";
      case SLIVER: return "sliver";
      case MEDIUM_SKINNY: return "medium_skinny";
      case UNRESOLVED: return "unresolved";
      case NONE: return "none";
    }
    assert(0);
    return "ASSERTION FAILURE";
  }

  virtual ~WorkItem() { }
  virtual double size() const = 0;
  virtual size_t topological() const = 0;
  virtual Reason getReason() const = 0;
  virtual bool isActive() const = 0;

  virtual bool split(SplitData&) = 0;

  virtual std::string toString() const = 0;

  private:
  template <class Derived>
  class AllocatedItem : public WorkItem, public hudson::SmallMemoryItem<Derived> { };

  template <class Derived>
  class BallBased : public AllocatedItem<Derived> {
    protected:
    Ball *ball_;

    BallBased(Ball *b) : ball_(b) {
      assert(ball_);
    }
    public:
    virtual double size() const { return ball_->center().radius2; }
    virtual size_t topological() const { return ball_->topological(); }

    virtual bool split(SplitData& sdata) {
      return ball_->split(sdata);
    }
    virtual std::string toString() const {
      return WorkItem::toString(getReason()) + std::string(" ball ") + ball_->toString();
    }
  };

  template <class Derived>
  class VertexBasedAmbient : public AllocatedItem<Derived> {
    protected:
    Vertex *vertex_;
    TopMesh *mesh_;

    VertexBasedAmbient(Vertex *v, TopMesh *m) : vertex_(v), mesh_(m) {
      assert(vertex_);
    }
    public:
    virtual double size() const { return 1.0; } /* TODO: order? */
    virtual size_t topological() const { return ambient; }
    virtual std::string toString() const {
      return WorkItem::toString(getReason()) + std::string(" vertex ") + vertex_->toString();
    }
    virtual bool split(SplitData& sdata) {
      return mesh_->split(vertex_, sdata);
    }
    virtual bool isActive() const { return this->vertex_->isCrowded(mesh_); }
  };


  public:
  class NewBoundaryVertex : public AllocatedItem<NewBoundaryVertex> {
    Ball *ball_;
    Vertex *hint_;

    public:
    NewBoundaryVertex(Ball *b, Vertex *hint) : ball_(b), hint_(hint) {
      assert(ball_);
      assert(hint_);
    }

    virtual double size() const { return ball_->center().radius2; }
    virtual size_t topological() const { return ball_->topological(); }

    virtual bool split(SplitData& sdata) {
      return ball_->split(sdata, hint_, true);
    }

    virtual std::string toString() const {
      return WorkItem::toString(getReason()) + std::string(" ball ") + ball_->toString()
        + std::string(" [hint: ") + hint_->toString() + std::string("]");
    }
    virtual Reason getReason() const { return NEW_BOUNDARY_VERTEX; }
    virtual bool isActive() const { return this->ball_->isLive(); }
  };

  struct Encroached : public BallBased<Encroached> {
    Encroached(Ball *b) :  BallBased<Encroached> (b) { }
    virtual Reason getReason() const { return ENCROACHED; }
    virtual bool isActive() const { return this->ball_->isLive(); }
  };

  struct VerySkinny : public BallBased<VerySkinny> {
    VerySkinny(Ball *b) :  BallBased<VerySkinny> (b) { }
    virtual Reason getReason() const { return VERY_SKINNY; }
    virtual bool isActive() const { return this->ball_->isLive(); }
  };

  struct CrowdedSteiner : public VertexBasedAmbient<CrowdedSteiner> {
    CrowdedSteiner(Vertex *v, TopMesh *m) :  VertexBasedAmbient<CrowdedSteiner> (v, m) { }
    virtual Reason getReason() const { return CROWDED_STEINER; }
  };

  struct CrowdedInput : public VertexBasedAmbient<CrowdedInput> {
    CrowdedInput(Vertex *v, TopMesh *m) :  VertexBasedAmbient<CrowdedInput> (v, m) { }
    virtual Reason getReason() const { return CROWDED_INPUT; }
  };

  struct Sliver : public BallBased<Sliver> {
    Sliver(Ball *b) :  BallBased<Sliver> (b) { }
    virtual Reason getReason() const { return SLIVER; }
    virtual bool isActive() const { return this->ball_->isLive(); }
  };

  struct MediumSkinny : public BallBased<MediumSkinny> {
    MediumSkinny(Ball *b) :  BallBased<MediumSkinny> (b) { }
    virtual Reason getReason() const { return MEDIUM_SKINNY; }
    virtual bool isActive() const { return this->ball_->isLive(); }
  };

  struct Unresolved : public BallBased<Unresolved> {
    Unresolved(Ball *b) :  BallBased<Unresolved> (b) { }
    virtual Reason getReason() const { return UNRESOLVED; }
    virtual bool isActive() const {
      return this->ball_->isLive() && !this->ball_->isResolved();
    }
  };
};

#endif

---