facetteTraceTypes.hh

Go to the documentation of this file.

 
#ifndef facetteTracetypes_hh
#define facetteTracetypes_hh
 
#define FacetteTraceDeconstr_D  0
 
 
#include <map>
#include "geometry/semantics.hh"
#include "geometry/connectorSet.hh"
#include "geometry/normalVector.hh"
#include "toolbox/hashMap.hh"
 
namespace concepts {
 
  template<class NormalVectorRule>
  class FacetteTraceType : public OutputOperator {
  public:
    enum traceTypes { FIRST, MEAN, JUMP, PLUS, MINUS, BDD };
 
    //by default look outward first and use first trace only
    FacetteTraceType(): type_(FIRST), normalVectorRule_(NormalVectorRule().clone()) {}
 
    FacetteTraceType(const FacetteTraceType& fttype):
      type_(fttype.type_), normalVectorRule_(fttype.normalVectorRule_->clone()){}
 
 
    FacetteTraceType(const enum traceTypes type,const NormalVectorRule& normalVectorRule= NormalVectorRule()):
      type_(type), normalVectorRule_(normalVectorRule.clone()){}
 
    virtual ~FacetteTraceType(){
      DEBUGL(FacetteTraceDeconstr_D, "Delete done.")
    }
 
    FacetteTraceType<NormalVectorRule>& operator=(const FacetteTraceType& fttype) {
      if (&fttype != this) {
        type_       = fttype.type_;
        normalVectorRule_.reset(fttype.normalVectorRule_->clone());
      }
      return *this;
    }
 
    std::string typeStr() const{
        switch(type_) {
        case FIRST  : return "FIRST"; break;
        case MEAN   : return "MEAN"; break;
        case JUMP : return "JUMP"; break;
        case PLUS   : return "PLUS"; break;
        case MINUS  : return "MINUS"; break;
        default: return "UNDEFINED";
        }
    }
 
    enum traceTypes type() const { return type_; }
 
    const NormalVectorRule& rule() const{return  *normalVectorRule_;}
 
  protected:
      virtual std::ostream& info(std::ostream& os) const{
        return os << concepts::typeOf(*this)<<" ("<< typeStr() <<", "<< *normalVectorRule_<<")";
    }
  private :
      //trace Type
    enum traceTypes type_;
    //normalvectorrule
    std::unique_ptr< NormalVectorRule> normalVectorRule_;
  };
 
 
  template<class NormalVectorRule>
  class FacetteTraceTypes : public Semantics<FacetteTraceType<NormalVectorRule> > {
  public:
 
    FacetteTraceTypes(){};
 
    virtual ~FacetteTraceTypes(){
      DEBUGL(FacetteTraceDeconstr_D, "Delete done.")
    }
 
    virtual FacetteTraceType<NormalVectorRule> operator()(Attribute attrib) const{
      typename std::map<uint,FacetteTraceType<NormalVectorRule> >::const_iterator i = facetteTraceTypes_.find(attrib.attrib());
      DEBUGL(FacetteTraceDeconstr_D, "i = " << i->second)
      assert( i != facetteTraceTypes_.end());
      return i->second;
    }
 
 
      void add(const Attribute& attrib, const FacetteTraceType<NormalVectorRule>& fttObject){
          facetteTraceTypes_[attrib.attrib()]= fttObject;
      }
 
      void add(const Set<Attribute>& attrib, const  FacetteTraceType<NormalVectorRule>& fttObject){
        Set<Attribute>::const_iterator iter = attrib.begin();
        for( ; iter != attrib.end(); iter++){
            facetteTraceTypes_[iter->attrib()]= fttObject;
        }
      }
 
     Set<uint> domain() const {
        Set<uint> domain;
        typename std::map<uint, FacetteTraceType<NormalVectorRule> >::const_iterator iter = facetteTraceTypes_.begin();
            for( ; iter!= facetteTraceTypes_.end();iter++){
              domain.insert(iter->first);
            }
        return domain;
      }
 
  protected:
    virtual std::ostream& info(std::ostream& os) const{
      os<< concepts::typeOf(*this)<<"["<<std::endl;
      typename std::map<uint,FacetteTraceType<NormalVectorRule> >::const_iterator iter = facetteTraceTypes_.begin();
      for( ; iter!= facetteTraceTypes_.end();iter++){
        os << "Attribute("<<iter->first<<") --> "<<(facetteTraceTypes_[iter->first])<<std::endl;
      }
      return os<<"]";
    }
  private:
    mutable std::map<uint, FacetteTraceType<NormalVectorRule> > facetteTraceTypes_;
  };
 
 
 
} // namespace concepts
 
#endif // facetteTracetypes_hh