connector.hh

Go to the documentation of this file.

 
#ifndef Connector_hh
#define Connector_hh
 
#include "basics/typedefs.hh"
#include "basics/outputOperator.hh"
#include <iostream>
 
namespace concepts {
 
  // ************************************************************* Attribute **
 
  class Attribute { 
    friend std::ostream& operator<<(std::ostream& os, const Attribute& a);
  public:
    inline Attribute(uint attrib = 0) : attrib_(attrib) {}
 
    int operator==(const Attribute& a) const { return attrib_ == a.attrib_; }
 
    inline operator uint() const { return attrib_; }
         
    inline uint attrib() const { return attrib_; }
 
    // change attribute
    inline void set(uint attrib){ attrib_ = attrib;}
  private:
    uint attrib_; 
  };
 
  // ******************************************************************* Key **
 
  class Key { 
    friend std::ostream& operator<<(std::ostream& os, const Key& k);
  public:
    inline Key(uint key = 0) : key_(key) {}
         
    inline int operator==(const Key& key) const { return key_ == key.key_; }
 
    inline operator uint() const { return key_; }
         
    inline uint key() const { return key_; }
 
    inline static uint noKey() { return (uint)-1; }
  private:
    uint key_; 
  };
 
  // ************************************************************* Connector **
 
  class Connector : public OutputOperator {
  public:
    Connector(const uint key, const Attribute attrib) :
      key_(key), attrib_(attrib) {}
 
    virtual Connector* child(uint i, bool mode = 0) = 0;
    virtual const Connector* child(uint i) const = 0;
 
    int operator==(const Connector& cntr) const { return key_ == cntr.key_; }
 
    const Key& key() const { return key_; }
 
    const Attribute& attrib() const { return attrib_; }
 
    //change attribute
    inline void setAttrib(uint attrb){ attrib_.set(attrb); }
 
    int related(const Connector& conn) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
    Key key_;
 
    Attribute attrib_;
  };
 
  bool operator<(const Connector& cntr_x, const Connector& cntr_y);
 
  // ************************************************************ Connector0 **
 
  class Connector0 : public Connector {
  public:
    inline Connector0(Attribute attrib) : Connector(cnt_++, attrib) {}
 
    virtual Connector0* child(uint i, bool mode = 0) = 0;
    virtual const Connector0* child(uint i) const = 0;
  protected:
    inline Connector0(const Attribute attrib, const Key& key)
      : Connector(key, attrib) {};
 
    static uint cnt_;
  };
 
  // ************************************************************ Connector1 **
 
  class Connector1 : public Connector {
  public:
    inline Connector1(Attribute attrib) : Connector(cnt_++, attrib) {}
 
    virtual Connector0* vertex(uint i) const = 0;
 
    virtual Connector1* child(uint i, bool mode = 0) = 0;
    virtual const Connector1* child(uint i) const = 0;
  protected:
    inline Connector1(const Attribute attrib, const Key& key)
      : Connector(key, attrib) {};
 
    static uint cnt_;
  };
 
  // ************************************************************ Connector2 **
 
  class Connector2 : public Connector {
  public:
    inline Connector2(Attribute attrib) : Connector(cnt_++, attrib) {}
 
    virtual Connector2* child(uint i, bool mode = 0) = 0;
    virtual const Connector2* child(uint i) const = 0;
 
    virtual Connector1* edge(uint i) const = 0;
 
    virtual Connector0* vertex(uint i) const = 0;
  protected: 
    inline Connector2(const Attribute attrib, const Key& key)
      : Connector(key, attrib) {};
 
    static  uint cnt_;
  };
 
  // ************************************************************ Connector3 **
 
  class Connector3 : public Connector {
  public:
    inline Connector3(Attribute attrib) : Connector(cnt_++, attrib) {}
 
    virtual Connector3* child(uint i, bool mode = 0) = 0;
    virtual const Connector3* child(uint i) const = 0;
 
    virtual Connector1* edge(uint i) const = 0;
 
    virtual Connector2* face(uint i) const = 0;
 
    virtual Connector0* vertex(uint i) const = 0;
  protected: 
    inline Connector3(const Attribute attrib, const Key& key)
      : Connector(key, attrib) {};
 
    static uint cnt_;
  };
 
} // namespace concepts
 
 
namespace test {
 
 
  // ********************************************************* ResetConnectorN **
 
  class ResetConnector0 : public concepts::Connector0 {
  public:
    static void reset() { cnt_ = 0; }
    static uint cnt() { return cnt_; }
  };
  class ResetConnector1 : public concepts::Connector1 {
  public:
    static void reset() { cnt_ = 0; }
    static uint cnt() { return cnt_; }
  };
  class ResetConnector2 : public concepts::Connector2 {
  public:
    static void reset() { cnt_ = 0; }
    static uint cnt() { return cnt_; }
  };
  class ResetConnector3 : public concepts::Connector3 {
  public:
    static void reset() { cnt_ = 0; }
    static uint cnt() { return cnt_; }
  };
}
 
#endif // Connector_hh