dofmapper.hh

#ifndef DUNE_FEM_DOFMAPPER_HH
#define DUNE_FEM_DOFMAPPER_HH
 
//- Dune includes
#include <dune/fem/misc/bartonnackmaninterface.hh>
#include <dune/fem/space/mapper/capabilities.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    //-------------------------------------------------------------------------
    //-
    //-  --MapperInterface
    //-
    //-------------------------------------------------------------------------
    template< class DofMapperTraits >
    class DofMapper
    : public Fem::BartonNackmanInterface< DofMapper< DofMapperTraits >,
                                     typename DofMapperTraits :: DofMapperType >
    {
      typedef DofMapper< DofMapperTraits > ThisType;
      typedef Fem::BartonNackmanInterface< ThisType, typename DofMapperTraits::DofMapperType > BaseType;
 
    public:
      typedef DofMapperTraits Traits;
 
      typedef typename Traits::DofMapperType DofMapperType;
 
      typedef typename Traits::ElementType ElementType;
 
      typedef typename Traits::SizeType SizeType;
 
      typedef ElementType EntityType;
 
    protected:
      using BaseType::asImp;
 
    public:
      SizeType size () const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().size());
        return asImp().size();
      }
 
      bool contains ( const int codim ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().contains( codim ) );
        return asImp().contains( codim );
      }
 
      bool fixedDataSize ( const int codim ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().fixedDataSize( codim ) );
        return asImp().fixedDataSize( codim );
      }
 
      template< class Functor >
      void mapEach ( const ElementType &element, Functor f ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().mapEach( element, f ) );
      }
 
      template< class Entity, class Functor >
      void mapEachEntityDof ( const Entity &entity, Functor f ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().mapEachEntityDof( entity, f ) );
      }
 
      int maxNumDofs () const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().maxNumDofs());
        return asImp().maxNumDofs();
      }
 
      SizeType numDofs ( const ElementType &element ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().numDofs( element ) );
        return asImp().numDofs( element );
      }
 
      template< class Entity >
      SizeType numEntityDofs ( const Entity &entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().numEntityDofs( entity ) );
        return asImp().numEntityDofs( entity );
      }
 
      void update ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().update() );
      }
    };
 
 
 
    //-------------------------------------------------------------------------
    //-
    //-  --AdaptiveMapperInterface
    //-
    //-------------------------------------------------------------------------
    template< class DofMapperTraits >
    class AdaptiveDofMapper
    : public DofMapper< DofMapperTraits >
    {
      typedef DofMapper< DofMapperTraits > BaseType;
 
    protected:
      using BaseType::asImp;
 
    public:
      typedef typename BaseType::SizeType SizeType;
 
      typedef SizeType GlobalKeyType;
 
      SizeType numberOfHoles ( const int block ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().numberOfHoles(block));
        return asImp().numberOfHoles(block);
      }
 
      GlobalKeyType oldIndex ( const int hole, const int block ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().oldIndex(hole,block));
        return asImp().oldIndex(hole,block);
      }
 
      GlobalKeyType newIndex ( const int hole, const int block ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().newIndex(hole,block));
        return asImp().newIndex(hole,block);
      }
 
      bool consecutive () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().consecutive() );
        return asImp().consecutive();
      }
 
      SizeType oldOffSet ( const int block ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().oldOffSet(block));
        return asImp().oldOffSet(block);
      }
 
      SizeType offSet ( const int block ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().offSet(block));
        return asImp().offSet(block);
      }
 
      SizeType numBlocks () const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().numBlocks());
        return asImp().numBlocks();
      }
 
      void update () {}
    };
 
 
  } // end namespace Fem
 
} // end namespace Dune
 
#endif // #ifndef DUNE_FEM_DOFMAPPER_HH