edgeMinMax.hh

Go to the documentation of this file.

 
#ifndef hp2DedgeMinMax_hh
#define hp2DedgeMinMax_hh
 
#include "basics/outputOperator.hh"
#include "basics/cloneable.hh"
 
namespace hp2D {
 
  // ********************************************************** PolyEdgeRule **
 
  class PolyEdgeRule : public concepts::OutputOperator,
           public concepts::Cloneable {
  public:
    virtual PolyEdgeRule* clone() const = 0;
    virtual void pUnderChildren(ushort& p, ushort pChild) const = 0;
    virtual void pFromChildren(ushort& p, ushort pChild) const {
      p = std::min(p, pChild); // seems to be equal as 
    }
    virtual void pEdge(ushort& p, ushort pEdge) const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << concepts::typeOf(*this)<<"()";
    }
  };
    
    
  // *********************************************************** PolyEdgeMax **
 
  class PolyEdgeMax : public PolyEdgeRule {
  public:
    virtual PolyEdgeMax* clone() const { return new PolyEdgeMax(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pFromChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::max(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << concepts::typeOf(*this)<<"()";
    }
  };
 
  // *********************************************************** PolyEdgeMin **
 
  class PolyEdgeMin : public PolyEdgeRule {
  public:
    virtual PolyEdgeMin* clone() const { return new PolyEdgeMin(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::min(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::min(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << concepts::typeOf(*this)<<"()";
    }
  };
 
  // ********************************************** PolyEdgeMinNeighMaxChild **
 
  class PolyEdgeMinNeighMaxChild : public PolyEdgeRule {
  public:
    virtual PolyEdgeMinNeighMaxChild* clone() const { 
      return new PolyEdgeMinNeighMaxChild(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::min(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << concepts::typeOf(*this)<<"()";
    }
  };
 
} // namespace hp2D
 
#endif // hp2DedgeMinMax_hh