>From the metting minutes:

- GeometryType vs. topologyId
  Both shall be merged into GeometryType
    * method id() shall return the topologyId
    * method basicType() shall be extended to return not presentable

Changes:
- GeometryType uses the topologyId internally to represent all types
  covered by topologyId
- an additional flag marks none-state
- new BasicType extended for all topologyId-types not coverd by BasicType
- new method id()

Tested with current dune-grid tests

[[Imported from SVN: r6255]]

dune/common/geometrytype.hh

@@ -28,69 +28,154 @@ namespace Dune {
       cube,                  //!< Cube element in any nonnegative dimension
       pyramid,               //!< Four sided pyramid in three dimensions
       prism,                 //!< Prism element in three dimensions
+      extended,      //!< Other, more general geometry, representable as topologyId
       none                   //!< Generic element in any nonnegative dimension
     };
 
   private:
 
-    /** \brief Basic type of the element */
-    BasicType basicType_;
+    /** \brief Topology Id element */
+    unsigned int topologyId_;
 
     /** \brief Dimension of the element */
-    unsigned int dim_;
+    unsigned char dim_  : 7;
+
+    /** \brief bool if this is none-type */
+    bool none_ : 1;
 
   public:
     /** \brief Default constructor, not initializing anything */
     GeometryType ()
+      : topologyId_(0), dim_(0), none_(true)
     {}
 
     /** \brief Constructor */
     GeometryType(BasicType basicType, unsigned int dim)
-      : basicType_(basicType), dim_(dim)
+      : topologyId_(0), dim_(dim), none_(false)
+    {
+      if (dim < 2)
+        return;
+      switch( basicType )
+      {
+      case GeometryType::simplex :
+        makeSimplex(dim);
+        break;
+      case GeometryType::cube :
+        makeCube(dim);
+        break;
+      case GeometryType::pyramid :
+        if (dim == 3)
+          makePyramid();
+        break;
+      case GeometryType::prism :
+        if (dim == 3)
+          makePrism();
+        break;
+      case GeometryType::none :
+        makeNone(dim);
+        break;
+      default :
+        DUNE_THROW( RangeError,
+                    "Invalid basic geometry type: " << basicType << " for dimension " << dim << "." );
+      }
+    }
+
+    /** \brief Constructor */
+    GeometryType(unsigned int topologyId, unsigned int dim)
+      : topologyId_(topologyId), dim_(dim), none_(false)
     {}
 
-    /** \brief Constructor for vertices and segments
-        \todo Add check for dim={0,1} when compiled with a suitable flag
-     */
-    explicit GeometryType(unsigned int dim)
-      : basicType_(cube), dim_(dim)
+    /** \brief Constructor */
+    template<class TopologyType>
+    GeometryType(TopologyType t)
+      : topologyId_(TopologyType::id), dim_(TopologyType::dimension), none_(false)
     {}
 
+    /** \brief Constructor for vertices and segments */
+    explicit GeometryType(unsigned int dim)
+      : topologyId_(0), dim_(dim), none_(false)
+    {
+      assert(dim < 2);
+    }
+
+    /** \brief Constructor for vertices and segments */
+    explicit GeometryType(int dim)
+      : topologyId_(0), dim_(dim), none_(false)
+    {
+      assert(dim < 2);
+    }
+
     /** @name Setup Methods */
     /*@{*/
 
     /** \brief Make a vertex */
-    void makeVertex() {dim_ = 0;}
+    void makeVertex() {
+      none_  = false;
+      dim_ = 0;
+      topologyId_ = 0;
+    }
 
     /** \brief Make a line segment */
-    void makeLine() {dim_ = 1;}
+    void makeLine() {
+      none_  = false;
+      dim_ = 1;
+      topologyId_ = 0;
+    }
 
     /** \brief Make a triangle */
-    void makeTriangle() {basicType_ = simplex; dim_ = 2;}
+    void makeTriangle() {
+      makeSimplex(2);
+    }
 
     /** \brief Make a quadrilateral */
-    void makeQuadrilateral() {basicType_ = cube; dim_ = 2;}
+    void makeQuadrilateral() {
+      makeCube(2);
+    }
 
     /** \brief Make a tetrahedron */
-    void makeTetrahedron() {basicType_ = simplex; dim_ = 3;}
+    void makeTetrahedron() {
+      makeSimplex(3);
+    }
 
     /** \brief Make a pyramid */
-    void makePyramid() {basicType_ = pyramid;  dim_ = 3;}
+    void makePyramid() {
+      none_  = false;
+      dim_ = 3;
+      topologyId_ = 0b0011;
+    }
 
     /** \brief Make a prism */
-    void makePrism() {basicType_ = prism;  dim_ = 3;}
+    void makePrism() {
+      none_  = false;
+      dim_ = 3;
+      topologyId_ = 0b0101;       // (1 << (dim_-1)) - 1;
+    }
 
     /** \brief Make a hexahedron */
-    void makeHexahedron() {basicType_ = cube; dim_ = 3;}
+    void makeHexahedron() {
+      makeCube(3);
+    }
 
     /** \brief Make a simplex of given dimension */
-    void makeSimplex(unsigned int dim) {basicType_ = simplex; dim_ = dim;}
+    void makeSimplex(unsigned int dim) {
+      none_  = false;
+      dim_ = dim;
+      topologyId_ = 0;
+    }
 
     /** \brief Make a hypercube of given dimension */
-    void makeCube(unsigned int dim) {basicType_ = cube; dim_ = dim;}
+    void makeCube(unsigned int dim) {
+      none_  = false;
+      dim_ = dim;
+      topologyId_ = ((dim>1) ? ((1 << dim) - 1) : 0);
+    }
 
     /** \brief Make a singular of given dimension */
-    void makeNone(unsigned int dim) {basicType_ = none; dim_ = dim;}
+    void makeNone(unsigned int dim) {
+      none_ = true;
+      dim_ = dim;
+      topologyId_  = 0;
+    }
 
     /*@}*/
 
@@ -98,43 +183,84 @@ namespace Dune {
     /** @name Query Methods */
     /*@{*/
     /** \brief Return true if entity is a vertex */
-    bool isVertex() const {return dim_==0;}
+    bool isVertex() const {
+      return dim_==0;
+    }
 
     /** \brief Return true if entity is a line segment */
-    bool isLine() const {return dim_==1;}
+    bool isLine() const {
+      return dim_==1;
+    }
 
     /** \brief Return true if entity is a triangle */
-    bool isTriangle() const {return basicType_==simplex && dim_==2;}
+    bool isTriangle() const {
+      return ! none_ && dim_==2 && (topologyId_ | 1) == 0b0001;
+    }
 
     /** \brief Return true if entity is a quadrilateral */
-    bool isQuadrilateral() const {return basicType_==cube && dim_==2;}
+    bool isQuadrilateral() const {
+      return ! none_ && dim_==2 && (topologyId_ | 1) == 0b0011;
+    }
 
     /** \brief Return true if entity is a tetrahedron */
-    bool isTetrahedron() const {return basicType_==simplex && dim_==3;}
+    bool isTetrahedron() const {
+      return ! none_ && dim_==3 && (topologyId_ | 1) == 0b0001;
+    }
 
     /** \brief Return true if entity is a pyramid */
-    bool isPyramid() const {return basicType_==pyramid;}
+    bool isPyramid() const {
+      return ! none_ && dim_==3 && (topologyId_ | 1) == 0b0011;
+    }
 
     /** \brief Return true if entity is a prism */
-    bool isPrism() const {return basicType_==prism;}
+    bool isPrism() const {
+      return ! none_ && dim_==3 && (topologyId_ | 1) == 0b0101;
+    }
 
     /** \brief Return true if entity is a hexahedron */
-    bool isHexahedron() const {return basicType_==cube && dim_==3;}
+    bool isHexahedron() const {
+      return ! none_ && dim_==3 && (topologyId_ | 1) == 0b0111;
+    }
 
     /** \brief Return true if entity is a simplex of any dimension */
-    bool isSimplex() const {return basicType_==simplex || dim_ < 2;}
+    bool isSimplex() const {
+      return ! none_ && (topologyId_ | 1) == 1;
+    }
 
     /** \brief Return true if entity is a cube of any dimension */
-    bool isCube() const {return basicType_==cube || dim_ < 2;}
+    bool isCube() const {
+      return ! none_ && (topologyId_ | 1) == (unsigned int)((1<<dim_)-1);
+    }
 
     /** \brief Return true if entity is a singular of any dimension */
-    bool isNone() const {return basicType_==none;}
+    bool isNone() const {
+      return none_;
+    }
+
+    /** \brief Return dimension of the type */
+    unsigned int dim() const {
+      return dim_;
+    }
 
-    /** \brief Return dimension of the entity */
-    unsigned int dim() const {return dim_;}
+    /** \brief Return the basic type of the type */
+    BasicType basicType() const DUNE_DEPRECATED {
+      if (isSimplex())
+        return GeometryType::simplex;
+      if (isCube())
+        return GeometryType::cube;
+      if (isPyramid())
+        return GeometryType::pyramid;
+      if (isPrism())
+        return GeometryType::prism;
+      if (isNone())
+        return GeometryType::none;
+      return GeometryType::extended;
+    }
 
-    /** \brief Return the basic type of the entity */
-    BasicType basicType() const {return basicType_;}
+    /** \brief Return the topology id the type */
+    unsigned int id() const {
+      return topologyId_;
+    }
 
     /*@}*/
 
@@ -142,9 +268,15 @@ namespace Dune {
                     all BasicTypes are equal.
      */
     bool operator==(const GeometryType& other) const {
-      return ( (dim()==0 && other.dim()==0)
-               || (dim()==1 && other.dim()==1)
-               || (dim()==other.dim() && basicType_==other.basicType_) );
+      return ( ( none_ == other.none_ )
+               && ( ( none_ == true )
+                    || ( ( dim_ == other.dim_ )
+                         && ( ( dim_ < 2 )
+                              || ( topologyId_ == other.topologyId_ )
+                              )
+                         )
+                    )
+               );
     }
 
     /** \brief Check for inequality */
@@ -154,39 +286,46 @@ namespace Dune {
 
     /** \brief lesser operation for use with maps */
     bool operator < (const GeometryType& other) const {
-      if (dim() != other.dim())
-        return dim() < other.dim();
-      else if (dim()==0 || dim()==1)
+      if (none)
         return false;
-
-      return basicType_ < other.basicType_;
+      if (other.none)
+        return true;
+      return ( ( dim_ < other.dim_ )
+               || ( !( other.dim_ < dim_ )
+                    && ( topologyId_ < other.topologyId_ ) )
+               );
     }
-
-    friend inline std::ostream& operator<< (std::ostream& s, const GeometryType& a);
   };
 
   /** \brief Prints the type to an output stream */
   inline std::ostream& operator<< (std::ostream& s, const GeometryType& a)
   {
-    switch (a.basicType_) {
-    case GeometryType::simplex :
-      s << "(simplex, " << a.dim_ << ")";
-      break;
-    case GeometryType::cube :
-      s << "(cube, " << a.dim_ << ")";
-      break;
-    case GeometryType::pyramid :
-      s << "pyramid";
-      break;
-    case GeometryType::prism :
-      s << "prism";
-      break;
-    case GeometryType::none :
-      s << "(none, " << a.dim_ << ")";
-      break;
-    default :
-      s << "invalid geometry type";
+    if (a.isSimplex())
+    {
+      s << "(__simplex, " << a.dim() << ")";
+      return s;
+    }
+    if (a.isCube())
+    {
+      s << "(cube, " << a.dim() << ")";
+      return s;
+    }
+    if (a.isPyramid())
+    {
+      s << "(pyramid, 3)";
+      return s;
+    }
+    if (a.isPrism())
+    {
+      s << "(prism, 3)";
+      return s;
+    }
+    if (a.isNone())
+    {
+      s << "(none, " << a.dim() << ")";
+      return s;
     }
+    s << "(other [" << a.id() << "], " << a.dim() << ")";
     return s;
   }
 
@@ -206,11 +345,13 @@ namespace Dune {
     case GeometryType::prism :
       s << "prism";
       break;
+    case GeometryType::extended :
+      s << "other";
     case GeometryType::none :
       s << "none";
       break;
     default :
-      s << "[unknown GeometryType::BasicType: " << int(type) << "]";
+      DUNE_THROW(Exception, "invalid GeometryType::BasicType");
     }
     return s;
   }