geometry/connector.hh

Go to the documentation of this file.

/* Connectors.
 * connectivity informations.
 */

#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_; }
  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_; }

    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