entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_ENTITY_HH
#define DUNE_GRID_ENTITY_HH
 
#include <type_traits>
 
#include <dune/common/iteratorrange.hh>
#include <dune/common/typetraits.hh>
 
#include <dune/geometry/dimension.hh>
#include <dune/geometry/referenceelements.hh>
 
#include "grid.hh"
#include "rangegenerators.hh"
 
namespace Dune
{
 
  template<int cd, int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity
  {
  public:
    typedef EntityImp< cd, dim, GridImp > Implementation;
 
    Implementation &impl () { return realEntity; }
    const Implementation &impl () const { return realEntity; }
 
  protected:
    Implementation realEntity;
 
  public:
 
    //===========================================================
    //===========================================================
 
    typedef typename GridImp::template Codim<cd>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
 
    enum {
      codimension=cd
    };
    enum {
      dimension=dim
    };
    enum {
      mydimension=dim-cd
    };
 
 
 
    //===========================================================
    //===========================================================
 
    int level () const { return realEntity.level(); }
 
    PartitionType partitionType () const { return realEntity.partitionType(); }
 
    Geometry geometry () const { return realEntity.geometry(); }
 
    GeometryType type () const { return realEntity.type(); }
 
    unsigned int subEntities ( unsigned int codim ) const
    {
      return realEntity.subEntities(codim);
    }
 
    EntitySeed seed () const { return realEntity.seed(); }
 
    bool operator==(const Entity& other) const
    {
      return realEntity.equals(other.realEntity);
    }
 
    bool operator!=(const Entity& other) const
    {
      return !realEntity.equals(other.realEntity);
    }
 
    Entity()
    {}
 
    Entity(const Entity& other)
      : realEntity(other.realEntity)
    {}
 
    Entity(Entity&& other)
      : realEntity(std::move(other.realEntity))
    {}
 
    Entity& operator=(const Entity& other)
    {
      realEntity = other.realEntity;
      return *this;
    }
 
    Entity& operator=(Entity&& other)
    {
      realEntity = std::move(other.realEntity);
      return *this;
    }
 
 
    //===========================================================
    //===========================================================
 
    Entity(const EntityImp<cd,dim,GridImp> & e) : realEntity(e) {}
 
    Entity(EntityImp<cd,dim,GridImp> && e) : realEntity(std::move(e)) {}
 
  };
 
  template<int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity <0,dim,GridImp,EntityImp>
  {
  public:
    typedef EntityImp< 0, dim, GridImp > Implementation;
 
    Implementation &impl () { return realEntity; }
    const Implementation &impl () const { return realEntity; }
 
  protected:
    Implementation realEntity;
 
  public:
 
    //===========================================================
    //===========================================================
 
    typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
    template <int cd>
    struct Codim
    {
      typedef typename GridImp::template Codim<cd>::Entity Entity;
    };
 
    typedef typename GridImp::HierarchicIterator HierarchicIterator;
 
    enum {
      codimension=0
    };
    enum {
      dimension=dim
    };
    enum {
      mydimension=dim
    };
 
 
    //===========================================================
    //===========================================================
 
    int level () const { return realEntity.level(); }
 
    PartitionType partitionType () const { return realEntity.partitionType(); }
 
    Geometry geometry () const { return realEntity.geometry(); }
 
    unsigned int subEntities ( unsigned int codim ) const
    {
      return realEntity.subEntities(codim);
    }
 
    GeometryType type () const { return realEntity.type(); }
 
    EntitySeed seed () const { return realEntity.seed(); }
 
    bool operator==(const Entity& other) const
    {
      return realEntity.equals(other.realEntity);
    }
 
    bool operator!=(const Entity& other) const
    {
      return !realEntity.equals(other.realEntity);
    }
 
    Entity()
    {}
 
    Entity(const Entity& other)
      : realEntity(other.realEntity)
    {}
 
    Entity(Entity&& other)
      : realEntity(std::move(other.realEntity))
    {}
 
    Entity& operator=(const Entity& other)
    {
      realEntity = other.realEntity;
      return *this;
    }
 
    Entity& operator=(Entity&& other)
    {
      realEntity = std::move(other.realEntity);
      return *this;
    }
 
 
    //===========================================================
    //===========================================================
 
    template< int codim >
    typename Codim< codim >::Entity
    subEntity ( int i ) const
    {
      return realEntity.template subEntity< codim >( i );
    }
 
    Entity father () const
    {
      return realEntity.father();
    }
 
    bool hasFather () const
    {
      return realEntity.hasFather();
    }
 
    bool isLeaf () const
    {
      return realEntity.isLeaf();
    }
 
    bool isRegular() const { return realEntity.isRegular(); }
 
    LocalGeometry geometryInFather () const { return realEntity.geometryInFather(); }
 
    HierarchicIterator hbegin (int maxLevel) const
    {
      return realEntity.hbegin(maxLevel);
    }
 
    HierarchicIterator hend (int maxLevel) const
    {
      return realEntity.hend(maxLevel);
    }
 
    bool isNew () const { return realEntity.isNew(); }
 
    bool mightVanish () const { return realEntity.mightVanish(); }
 
    bool hasBoundaryIntersections () const { return realEntity.hasBoundaryIntersections(); }
 
 
    //===========================================================
    //===========================================================
 
    Entity(const EntityImp<0,dim,GridImp> & e) : realEntity(e) {}
 
    Entity(EntityImp<0,dim,GridImp> && e) : realEntity(std::move(e)) {}
 
  };
 
 
 
  //********************************************************************
  template<int cd, int dim, class GridImp, template<int,int,class> class EntityImp>
  class EntityDefaultImplementation
  {
  public:
    enum { codimension=cd };
 
    enum { dimension=dim };
 
    enum { mydimension=dim-cd };
 
    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
 
    unsigned int subEntities ( unsigned int codim ) const
    {
      typedef typename std::remove_const< GridImp >::type::ctype ctype;
      return ReferenceElements< ctype, mydimension >::general( asImp().type() ).size( codim - codimension );
    }
 
    GeometryType type () const { return asImp().geometry().type(); }
 
  private:
    EntityImp<cd,dim,GridImp>& asImp ()
    {
      return static_cast<EntityImp<cd,dim,GridImp>&>(*this);
    }
    const EntityImp<cd,dim,GridImp>& asImp () const
    {
      return static_cast<const EntityImp<cd,dim,GridImp>&>(*this);
    }
  }; // end EntityDefaultImplementation
 
  //********************************************************************
  template<int dim, class GridImp, template<int,int,class> class EntityImp>
  class EntityDefaultImplementation <0,dim,GridImp,EntityImp>
  {
  public:
    enum { codimension=0 };
 
    enum { dimension=dim };
 
    enum { mydimension=dim };
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    bool isRegular() const { return true; }
 
    unsigned int subEntities ( unsigned int codim ) const
    {
      typedef typename std::remove_const< GridImp >::type::ctype ctype;
      return ReferenceElements< ctype, mydimension >::general( asImp().type() ).size( codim - codimension );
    }
 
    GeometryType type () const { return asImp().geometry().type(); }
 
    bool isNew () const { return false; }
 
    bool mightVanish () const { return false; }
 
    bool hasBoundaryIntersections () const
    {
      typedef typename GridImp::LevelIntersectionIterator IntersectionIterator;
      IntersectionIterator end = asImp().ilevelend();
      for (IntersectionIterator it = asImp().ilevelbegin(); it != end; ++it)
        if( it->boundary() )
          return true;
 
      return false;
    }
 
  private:
    //  Barton-Nackman trick
    EntityImp<0,dim,GridImp>& asImp () { return static_cast<EntityImp<0,dim,GridImp>&>(*this); }
    const EntityImp<0,dim,GridImp>& asImp () const { return static_cast<const EntityImp<0,dim,GridImp>&>(*this); }
  };
 
 
  template< int cd, int dim, class GridImp, template<int,int,class> class EntityImp >
  auto referenceElement(const Entity< cd, dim, GridImp, EntityImp >& entity )
    -> decltype(referenceElement<typename GridImp::ctype,GridImp::template Codim<cd>::Geometry::mydimension>(entity.type()))
  {
    typedef typename GridImp::template Codim<cd>::Geometry Geo;
    return referenceElement< typename Geo::ctype, Geo::mydimension >(entity.type());
  }
}
 
#endif // DUNE_GRID_ENTITY_HH