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/iteratorrange.hh>
#include <dune/common/typetraits.hh>
 
#include <dune/geometry/dimension.hh>
 
#include "grid.hh"
#include "entitypointer.hh"
#include "rangegenerators.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
    };
 
 
 
    //===========================================================
    //===========================================================
 
    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(); }
 
    bool operator==(const Entity& other) const
    {
      return realEntity.equals(other.realEntity);
    }
 
    bool operator!=(const Entity& other) const
    {
      return !realEntity.equals(other.realEntity);
    }
 
    template<typename ItImp>
    DUNE_DEPRECATED_MSG("EntityPointer is deprecated and will be removed after the release of dune-grid-2.4. Instead, you can copy and store entities directly now.")
    bool operator==(const Dune::EntityPointer<GridImp,ItImp>& other) const
    {
      return (*this) == (*other);
    }
 
    template<typename ItImp>
    DUNE_DEPRECATED_MSG("EntityPointer is deprecated and will be removed after the release of dune-grid-2.4. Instead, you can copy and store entities directly now.")
    bool operator!=(const Dune::EntityPointer<GridImp,ItImp>& other) const
    {
      return (*this) != (*other);
    }
 
    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;
    }
 
    const Entity& operator*() const
    DUNE_DEPRECATED_MSG("This is now an Entity instead of an EntityPointer. You do not have to dereference it anymore!")
    {
      return *this;
    }
 
    const Entity* operator->() const
    DUNE_DEPRECATED_MSG("This is now an Entity instead of an EntityPointer. You do not have to dereference it anymore!")
    {
      return this;
    }
 
 
    //===========================================================
    //===========================================================
 
    Entity(const EntityImp<cd,dim,GridImp> & e) : realEntity(e) {}
 
    Entity(EntityImp<cd,dim,GridImp> && e) : realEntity(std::move(e)) {}
 
 
  protected:
 
    // need to make copy constructor of EntityPointer work for any iterator
    template< class, class > friend class Dune::EntityPointer;
 
  };
 
  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<cd>::Entity Entity;
    };
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    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(); }
 
    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);
    }
 
    template<typename ItImp>
    DUNE_DEPRECATED_MSG("EntityPointer is deprecated and will be removed after the release of dune-grid-2.4. Instead, you can copy and store entities directly now.")
    bool operator==(const Dune::EntityPointer<GridImp,ItImp>& other) const
    {
      return (*this) == (*other);
    }
 
    template<typename ItImp>
    DUNE_DEPRECATED_MSG("EntityPointer is deprecated and will be removed after the release of dune-grid-2.4. Instead, you can copy and store entities directly now.")
    bool operator!=(const Dune::EntityPointer<GridImp,ItImp>& other) const
    {
      return (*this) != (*other);
    }
 
    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;
    }
 
    const Entity& operator*() const
    DUNE_DEPRECATED_MSG("This is now an Entity instead of an EntityPointer. You do not have to dereference it anymore!")
    {
      return *this;
    }
 
    const Entity* operator->() const
    DUNE_DEPRECATED_MSG("This is now an Entity instead of an EntityPointer. You do not have to dereference it anymore!")
    {
      return this;
    }
 
 
    //===========================================================
    //===========================================================
 
    template<int codim> int DUNE_DEPRECATED_MSG("Use subEntities(unsigned int) instead!") count () const { return realEntity.template count<codim>(); }
 
    unsigned int subEntities(unsigned int codim) const
    {
      return realEntity.subEntities(codim);
    }
 
#ifndef DOXYGEN
 
    // The following ugly helper struct is here to work around deficiencies in the decltype() implementation
    // of GCC 4.4.
    // If we try to merge the two typedefs in the struct and put them directly into the return value of
    // subEntity(), GCC 4.4 dies with an internal compiler error complaining that mangling of template_id_name
    // is not supported.
    // So we put everything into this separate struct and just instantiate it in the signature of subEntity()
    // which makes GCC 4.4 happy.
    template <int codim_>
    struct subentity_return_info
    {
 
      // Step 1: Obtain return value of subentity from implementation class
      //
      // it would be more readable to use std::declval() here, but that's another thing that's missing
      // GCC 4.4, so we do it the manual way with a static cast
      typedef decltype(
        static_cast<Implementation*>(nullptr)->template subEntity<codim_>(0)
        ) implementation_return_type;
 
      // Step 2: Check whether the implementation returned a facade entity or not
      // If yes -> declare Entity return type
      // If no  -> declare EntityPointer return type
      typedef typename std::conditional<
        std::is_same<
          implementation_return_type,
          typename Entity::template Codim<codim_>::Entity
        >::value,
        typename Entity::template Codim<codim_>::Entity,
       typename Entity::template Codim<codim_>::EntityPointer
        >::type type;
    };
 
#endif // DOXYGEN
 
    template< int codim >
#ifdef DOXYGEN
    typename Codim< codim >::Entity
#else
    typename subentity_return_info<codim>::type
#endif
    subEntity ( int i ) const
    {
      warnOnDeprecatedEntityPointer<typename subentity_return_info<codim>::type>();
      return realEntity.template subEntity< codim >( i );
    }
 
#ifdef DOXYGEN
    Entity
    father () const
#else
    template<typename Foo = void>
    typename std::conditional<
      std::is_same<
        decltype(realEntity.father()),
        Entity
        >::value,
      Entity,
      EntityPointer
      >::type
    father (typename std::enable_if<std::is_same<Foo,void>::value,void*>::type = nullptr) const
#endif
    {
      warnOnDeprecatedEntityPointer<decltype(realEntity.father())>();
      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)) {}
 
 
#ifndef DOXYGEN
 
    // these two methods are just here for the 2.4 transition from EntityPointer to Entity
    // they will generate a compile time warning if the grid implementation still returns
    // an EntityPointer from certain interface methods.
    // These methods are also required by the intersection facade, so I just made them public
    // and hid them from Doxygen. As they don't do anything remotely useful, I don't think any
    // user will try to call them manually... :-P
 
    // this non-warning version only matches if E is an entity that has been correctly wrapped
    // in a facade class
    template<typename E>
    static typename std::enable_if<
      std::is_same<
        E,
        typename Codim<E::codimension>::Entity
        >::value
      >::type
    warnOnDeprecatedEntityPointer()
    {}
 
    template<typename E>
    DUNE_DEPRECATED_MSG("This grid still returns EntityPointers instead of Entities")
    static typename std::enable_if<
      not std::is_same<
        E,
        typename Codim<E::codimension>::Entity
        >::value
      >::type
    warnOnDeprecatedEntityPointer()
    {}
 
#endif // DOXYGEN
 
  protected:
    // needed to make copy constructor from EntityPointer work for any iterator
    template< class, class > friend class Dune::EntityPointer;
 
  };
 
 
 
  //********************************************************************
  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;
 
    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 };
 
    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;
 
      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