typeindex.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOMETRY_TYPEINDEX_HH
#define DUNE_GEOMETRY_TYPEINDEX_HH
 
#include <cstddef>
 
#include "type.hh"
 
namespace Dune
{
  class LocalGeometryTypeIndex
  {
    inline static constexpr std::size_t regular_size(std::size_t dim)
    {
      // The following expression is derived from the expression for
      // GlobalGeometryTypeIndex::regular_offset().  Subtracting
      // regular_offset(dim+1)-regular_offset(dim) we get:
      //
      //   ((1 << dim+1) >> 1) - ((1 << dim) >> 1)
      //
      // We always have
      //
      //   dim >= 0,
      //
      // so
      //
      //   (1 << dim+1) >= 2   and   (1 << dim+2) % 2 == 0.
      //
      // So if we apply a single right-shift to that, we will never lose any
      // set bits, thus
      //
      //   ((1 << dim+1) >> 1) == (1 << dim)
      return (1 << dim) - ((1 << dim) >> 1);
    }
 
  public:
    inline static constexpr std::size_t size(std::size_t dim)
    {
      // one for "none"
      return regular_size(dim) + 1;
    }
 
    inline static std::size_t index(const GeometryType &gt)
    {
      if(gt.isNone())
      {
        return regular_size(gt.dim());
      }
      else
      {
        return gt.id() >> 1;
      }
    }
 
    inline static GeometryType type(std::size_t dim, std::size_t index) {
      if(index == regular_size(dim)) {
        GeometryType gt;
        gt.makeNone(dim);
        return gt;
      }
      else {
        // the cast to unsigned makes sure this is interpreted as the topology
        // ID constructor
        return GeometryType(unsigned(index << 1), dim);
      }
    }
  };
 
  class GlobalGeometryTypeIndex
  {
    inline static constexpr std::size_t regular_offset(std::size_t dim)
    {
      // The number of regular geometry types in a given dimension is
      // 2^(dim-1).  For dim==0 this would yield 1/2 geometry types (which is
      // obviously bogus, dim==0 has one regular geometry type, the point).
      // The following expression relies on 1 >> 1 == 0 to treat dim==0
      // specially.
      return (1 << dim) >> 1;
    }
 
  public:
    inline static constexpr std::size_t offset(std::size_t dim)
    {
      // dim times "none"
      return regular_offset(dim) + dim;
    }
 
    inline static constexpr std::size_t size(std::size_t maxdim)
    {
      return offset(maxdim+1);
    }
 
    inline static std::size_t index(const GeometryType &gt)
    {
      return offset(gt.dim()) + LocalGeometryTypeIndex::index(gt);
    }
  };
} // namespace Dune
 
#endif // DUNE_GEOMETRY_TYPEINDEX_HH