filter.hh

#ifndef DUNE_FEM_GRIDPART_FILTER_FILTER_HH
#define DUNE_FEM_GRIDPART_FILTER_FILTER_HH
 
//- system includes
#include <algorithm>
#include <cassert>
#include <vector>
 
//- dune-common includes
#include <dune/common/bartonnackmanifcheck.hh>
 
 
namespace Dune
{
 
  namespace Fem
  {
 
    // forward declarations
    // --------------------
 
    template< class > struct DefaultFilterTraits;
    template< class > class FilterInterface;
    template< class > class FilterDefaultImplementation;
 
 
    // DefaultFilterTraits
    // -------------------
 
    template < class FilterImp >
    struct DefaultFilterTraits
    {
      typedef FilterImp FilterType;
 
      template < int cd >
      struct Codim
      {
        typedef typename FilterType::template Codim< cd >::EntityType EntityType;
      };
 
      typedef typename Codim< 0 >::EntityType EntityType;
 
    }; // end DefaultFilterTraits
 
 
 
    // FilterInterface
    // ---------------
 
    template< class FilterTraits >
    class FilterInterface
    {
      typedef FilterInterface< FilterTraits > ThisType;
 
      friend class FilterDefaultImplementation< FilterTraits >;
 
      typedef FilterTraits Traits;
 
    public:
      typedef typename Traits :: FilterType FilterType;
 
      template< int cd >
      struct Codim
      {
        typedef typename Traits::template Codim< cd >::EntityType EntityType;
      };
 
      typedef typename Codim< 0 >::EntityType EntityType;
 
    private:
      FilterInterface () = default;
 
      FilterInterface ( const ThisType & ) = default;
      FilterInterface ( ThisType && ) = default;
 
      ThisType &operator= ( const ThisType & ) = default;
      ThisType &operator= ( ThisType && ) = default;
 
    public:
      template< int cd >
      bool contains ( const typename Codim< cd >::EntityType & entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().contains( entity ) );
        return asImp().template contains< cd >( entity );
      }
 
      template< class Entity >
      bool contains ( const Entity & entity ) const
      {
        enum { cc = Entity::codimension };
        CHECK_INTERFACE_IMPLEMENTATION( asImp().contains< cc >( entity ) );
        return asImp().template contains< cc >( entity );
      }
 
      //         (allows boundarys within a given domain)
      template< class Intersection >
      bool interiorIntersection ( const Intersection &intersection ) const
      {
        return asImp().interiorIntersection( intersection );
      }
 
      template< class Intersection >
      bool intersectionBoundary( const Intersection &intersection ) const
      {
        return asImp().intersectionBoundary( intersection );
      }
 
      template< class Intersection >
      int intersectionBoundaryId ( const Intersection &intersection ) const
      {
        return asImp().intersectionBoundaryId( intersection );
      }
 
      template< class Intersection >
      bool intersectionNeighbor ( const Intersection &intersection ) const
      {
        return asImp().intersectionNeighbor( intersection );
      }
 
    protected:
      FilterType &asImp ()
      {
        return static_cast< FilterType & >( *this );
      }
 
      const FilterType &asImp () const
      {
        return static_cast< const FilterType & >( *this );
      }
    };
 
 
    // FilterDefaultImplementation
    // ---------------------------
 
    template< class FilterTraits >
    class FilterDefaultImplementation
    : public FilterInterface< FilterTraits >
    {
      typedef FilterDefaultImplementation< FilterTraits > ThisType;
      typedef FilterInterface< FilterTraits > BaseType;
 
    public:
      typedef typename BaseType::FilterType FilterType;
 
      template< int cd >
      struct Codim
      {
        typedef typename BaseType::template Codim< cd >::EntityType EntityType;
      };
 
      typedef typename BaseType::EntityType EntityType;
 
    protected:
      using BaseType::asImp;
 
      FilterDefaultImplementation () = default;
 
      FilterDefaultImplementation ( const ThisType & ) = default;
      FilterDefaultImplementation ( ThisType && ) = default;
 
      ThisType &operator= ( const ThisType & ) = default;
      ThisType &operator= ( ThisType && ) = default;
 
    public:
      using BaseType::contains;
 
      template< class Intersection >
      bool interiorIntersection( const Intersection &intersection ) const
      {
        typedef typename Intersection::Entity EntityType;
        const EntityType outside(intersection.outside());
        return asImp().contains( outside );
      }
 
      template< int cd >
      bool contains ( const typename Codim< cd >::EntityType & ) const;
 
      template< class Intersection >
      bool intersectionBoundary( const Intersection & ) const;
 
      template< class Intersection >
      int intersectionBoundaryId ( const Intersection & ) const;
 
      template< class Intersection >
      bool intersectionNeighbor ( const Intersection & ) const;
    };
 
  }  // namespace Fem
 
}  // namespace Dune
 
#endif // #ifndef DUNE_FEM_GRIDPART_FILTER_FILTER_HH