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 <dune/common/typetraits.hh>
#include "grid.hh"
#include "entitypointer.hh"
 
namespace Dune
{
 
  template<int cd, int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity
  {
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
  public:
#else
  protected:
    // give the GridDefaultImplementation class access to the realImp
    friend class GridDefaultImplementation<
        GridImp::dimension, GridImp::dimensionworld,
        typename GridImp::ctype,
        typename GridImp::GridFamily> ;
 
    // Default*GridView classes need access to intersection iterators
    template< class, PartitionIteratorType > friend class DefaultLevelGridView;
    template< class, PartitionIteratorType > friend class DefaultLeafGridView;
#endif
    // type of underlying implementation, for internal use only
    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
    };
    static const int DUNE_DEPRECATED_MSG("Use Geometry::coorddimension instead!") dimensionworld=GridImp::dimensionworld;
 
    typedef typename GridImp::ctype ctype DUNE_DEPRECATED_MSG("Use Geometry::ctype instead!");
 
 
 
    //===========================================================
    //===========================================================
 
    int level () const { return realEntity.level(); }
 
    PartitionType partitionType () const { return realEntity.partitionType(); }
 
    Geometry geometry () const { return realEntity.geometry(); }
 
    GeometryType type () const { return realEntity.type(); }
 
    EntitySeed seed () const { return realEntity.seed(); }
 
    //===========================================================
    //===========================================================
 
    explicit Entity(const EntityImp<cd,dim,GridImp> & e) : realEntity(e) {}
 
 
  protected:
 
    // need to make copy constructor of EntityPointer work for any iterator
    template< class, class > friend class Dune::EntityPointer;
 
    Entity(const Entity& rhs) : realEntity(rhs.realEntity) {}
    Entity & operator = (const Entity& rhs) {
      realEntity = rhs.realEntity;
      return *this;
    }
 
  };
 
  template<int dim, class GridImp, template<int,int,class> class EntityImp>
  class Entity <0,dim,GridImp,EntityImp>
  {
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
  public:
#else
  protected:
    // give the GridDefaultImplementation class access to the realImp
    friend class GridDefaultImplementation<
        GridImp::dimension, GridImp::dimensionworld,
        typename GridImp::ctype,
        typename GridImp::GridFamily> ;
 
    // Default*GridView classes need access to intersection iterators
    template< class, PartitionIteratorType > friend class DefaultLevelGridView;
    template< class, PartitionIteratorType > friend class DefaultLeafGridView;
#endif
    // type of underlying implementation, for internal use only
    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>::EntityPointer EntityPointer;
    };
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    typedef typename GridImp::LeafIntersectionIterator LeafIntersectionIterator;
 
    typedef typename GridImp::LevelIntersectionIterator LevelIntersectionIterator;
 
    typedef typename GridImp::HierarchicIterator HierarchicIterator;
 
    enum {
      codimension=0
    };
    enum {
      dimension=dim
    };
    enum {
      mydimension=dim
    };
    static const int DUNE_DEPRECATED_MSG("Use Geometry::coorddimension instead!") dimensionworld=GridImp::dimensionworld;
 
    typedef typename GridImp::ctype ctype DUNE_DEPRECATED_MSG("Use Geometry::ctype instead!");
 
 
    //===========================================================
    //===========================================================
 
    int level () const { return realEntity.level(); }
 
    PartitionType partitionType () const { return realEntity.partitionType(); }
 
    Geometry geometry () const { return realEntity.geometry(); }
 
    GeometryType type () const { return realEntity.type(); }
 
    EntitySeed seed () const { return realEntity.seed(); }
 
    //===========================================================
    //===========================================================
 
    template<int cc> int count () const { return realEntity.template count<cc>(); }
 
    template< int codim >
    typename Codim< codim >::EntityPointer subEntity ( int i ) const
    {
      return realEntity.template subEntity< codim >( i );
    }
 
    LeafIntersectionIterator ileafbegin () const
    DUNE_DEPRECATED_MSG("Use LeafGridView.ibegin(Entity) instead.")
    {
      return realEntity.ileafbegin();
    }
 
    LeafIntersectionIterator ileafend () const
    DUNE_DEPRECATED_MSG("Use LeafGridView.iend(Entity) instead.")
    {
      return realEntity.ileafend();
    }
 
    LevelIntersectionIterator ilevelbegin () const
    DUNE_DEPRECATED_MSG("Use LevelGridView.ibegin(Entity) instead.")
    {
      return realEntity.ilevelbegin();
    }
 
    LevelIntersectionIterator ilevelend () const
    DUNE_DEPRECATED_MSG("Use LevelGridView.iend(Entity) instead.")
    {
      return realEntity.ilevelend();
    }
 
    EntityPointer 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(); }
 
    explicit Entity(const EntityImp<0,dim,GridImp> & e) : realEntity(e) {}
 
 
 
  protected:
    // needed to make copy constructor from EntityPointer work for any iterator
    template< class, class > friend class Dune::EntityPointer;
 
    Entity(const Entity& rhs) : realEntity(rhs.realEntity) {}
    Entity & operator = (const Entity& rhs) {
      realEntity = rhs.realEntity;
      return *this;
    }
 
  };
 
 
  //********************************************************************
  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 };
 
    static const int DUNE_DEPRECATED_MSG("Use Geometry::coorddimension instead!") dimensionworld=GridImp::dimensionworld;
 
    typedef typename GridImp::ctype ctype DUNE_DEPRECATED_MSG("Use Geometry::ctype instead!");
 
    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
 
    typedef typename GridImp::template Codim<cd>::EntityPointer EntityPointer;
 
    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 };
 
    static const int DUNE_DEPRECATED_MSG("Use Geometry::coorddimension instead!") dimensionworld=GridImp::dimensionworld;
 
    typedef typename GridImp::ctype ctype DUNE_DEPRECATED_MSG("Use Geometry::ctype instead!");
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    bool isRegular() const { return true; }
 
    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;
        }
      }
 
      {
        typedef typename GridImp::LeafIntersectionIterator IntersectionIterator;
        IntersectionIterator end = asImp().ileafend();
        for(IntersectionIterator it = asImp().ileafbegin(); 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); }
  };
 
}
 
#endif // DUNE_GRID_ENTITY_HH