entity.hh

#ifndef DUNE_FEM_GRIDPART_IDGRIDPART_ENTITY_HH
#define DUNE_FEM_GRIDPART_IDGRIDPART_ENTITY_HH
 
#include <type_traits>
#include <utility>
 
//- dune-grid includes
#include <dune/grid/common/entity.hh>
#include <dune/grid/common/gridenums.hh>
 
//- dune-fem includes
#include <dune/fem/gridpart/common/defaultgridpartentity.hh>
#include <dune/fem/gridpart/idgridpart/geometry.hh>
 
namespace Dune
{
  namespace Fem {
 
    // IdEntityBasic
    // -------------
 
    template< int codim, int dim, class GridFamily >
    class IdEntityBasic
      : public DefaultGridPartEntity < codim, dim, GridFamily >
    {
    protected:
      typedef typename std::remove_const< GridFamily >::type::Traits Traits;
 
    public:
      static const int codimension = codim;
      static const int dimension = std::remove_const< GridFamily >::type::dimension;
      static const int mydimension = dimension - codimension;
      static const int dimensionworld = std::remove_const< GridFamily >::type::dimensionworld;
 
      typedef typename std::remove_const< GridFamily >::type::ctype ctype;
 
      typedef typename GridFamily::template Codim< codimension >::EntitySeed EntitySeedType;
      typedef typename Traits::template Codim< codimension >::Geometry Geometry;
 
      // type of the host grid
      typedef typename Traits::HostGridPartType  HostGridPartType;
 
    protected:
      // type of extra data, e.g. a pointer to grid (here empty)
      typedef typename Traits::ExtraData ExtraData;
 
    public:
      typedef typename HostGridPartType::template Codim< codimension >::EntityType HostEntityType;
 
      IdEntityBasic () = default;
 
      IdEntityBasic ( ExtraData data, HostEntityType hostEntity )
      : data_( std::move( data ) ),
        hostEntity_( std::move( hostEntity ) )
      {}
 
      GeometryType type () const
      {
        return hostEntity().type();
      }
 
      int level () const
      {
        return hostEntity().level();
      }
 
      PartitionType partitionType () const
      {
        return hostEntity().partitionType();
      }
 
      Geometry geometry () const
      {
        return Geometry( hostEntity().geometry() );
      }
 
      EntitySeedType seed () const { return hostEntity().seed(); }
 
      bool equals ( const IdEntityBasic &rhs ) const
      {
        return hostEntity() == rhs.hostEntity();
      }
 
      const HostEntityType &hostEntity () const
      {
        return hostEntity_;
      }
 
      const ExtraData &data () const { return data_; }
 
    protected:
      ExtraData data_;
      HostEntityType hostEntity_;
    };
 
 
 
    // IdGridEntity
    // ------------
 
    template< int codim, int dim, class GridFamily >
    class IdEntity : public IdEntityBasic< codim, dim, GridFamily >
    {
      typedef IdEntityBasic< codim, dim, GridFamily > BaseType ;
    protected:
      typedef typename std::remove_const< GridFamily >::type::Traits Traits;
 
    public:
      // type of the host grid
      typedef typename Traits::HostGridPartType  HostGridPartType;
    protected:
      // type of extra data, e.g. a pointer to grid (here empty)
      typedef typename Traits::ExtraData ExtraData;
 
    public:
      using BaseType :: codimension ;
 
      typedef typename HostGridPartType::template Codim< codimension >::EntityType HostEntityType;
 
      IdEntity () = default;
 
      IdEntity ( ExtraData data, HostEntityType hostEntity )
      : BaseType( data, hostEntity )
      {}
    };
 
 
    // IdGridEntity for codimension 0
    // ----------------------------------
 
    template< int dim, class GridFamily >
    class IdEntity< 0, dim, GridFamily > : public IdEntityBasic< 0, dim, GridFamily >
    {
      typedef IdEntityBasic< 0, dim, GridFamily > BaseType ;
    protected:
      typedef typename BaseType::Traits Traits;
 
      // type of extra data, e.g. a pointer to grid (here empty)
      typedef typename BaseType::ExtraData ExtraData;
 
    public:
      typedef typename BaseType::HostGridPartType HostGridPartType;
 
      using BaseType::codimension ;
      using BaseType::data ;
      using BaseType::hostEntity ;
      typedef typename HostGridPartType::template Codim< codimension >::EntityType HostEntityType;
    public:
      typedef typename Traits::template Codim< codimension >::LocalGeometry LocalGeometry;
 
      IdEntity () = default;
 
      IdEntity ( ExtraData data, HostEntityType hostEntity )
      : BaseType( data, hostEntity )
      {}
 
      unsigned int subEntities( const unsigned int codim ) const
      {
        return hostEntity().subEntities( codim );
      }
 
      template< int codim >
      int count () const
      {
        return hostEntity().template count< codim >();
      }
 
      template< int codim >
      typename Traits::template Codim< codim >::Entity
      subEntity ( int i ) const
      {
        typedef typename Traits::template Codim< codim >::Entity::Implementation EntityImpl;
        return EntityImpl( data(), hostEntity().template subEntity< codim >( i ) );
      }
 
      bool hasBoundaryIntersections () const
      {
        return hostEntity().hasBoundaryIntersections();
      }
 
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_IDGRID_ENTITY_HH