intersectioniteratorwrapper.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_INTERSECTIONITERATORWRAPPER_HH
#define DUNE_INTERSECTIONITERATORWRAPPER_HH
 
#include <dune/grid/common/intersectioniterator.hh>
 
namespace Dune {
 
  template <class GridImp, class IntersectionIteratorImpl>
  class IntersectionIteratorWrapper
  {
    enum { dim = GridImp :: dimension };
    enum { dimworld = GridImp :: dimensionworld };
 
    typedef IntersectionIteratorWrapper<GridImp,IntersectionIteratorImpl> ThisType;
 
    typedef IntersectionIteratorImpl IntersectionIteratorImp;
 
    typedef typename IntersectionIteratorImp :: StorageType IntersectionIteratorProviderType;
 
  public:
    typedef typename GridImp :: GridObjectFactoryType FactoryType;
 
    enum { dimension      = dim };
    enum { dimensionworld = dimworld };
 
    typedef typename GridImp :: ctype ctype;
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
    typedef FieldVector<ctype , dimworld> NormalType;
 
    template <class EntityImp>
    IntersectionIteratorWrapper(const EntityImp & en, int wLevel , bool end)
      : factory_( en.factory() )
        , it_( factory_.getIntersection(wLevel, (IntersectionIteratorImpl *) 0) )
    {
      if(end)
        it().done( en );
      else
        it().first(en,wLevel);
    }
 
    IntersectionIteratorWrapper(const ThisType & org)
      : factory_( org.factory_ )
        , it_( factory_.getIntersection(-1, (IntersectionIteratorImpl *) 0) )
    {
      it().assign( org.it() );
    }
 
    ThisType & operator = (const ThisType & org)
    {
      it().assign( org.it() );
      return *this;
    }
 
    ~IntersectionIteratorWrapper()
    {
      factory_.freeIntersection( it() );
    }
 
    bool equals (const ThisType & i) const { return it().equals(i.it()); }
 
    void increment () { it().increment(); }
 
    EntityPointer outside() const { return it().outside(); }
 
    EntityPointer inside() const { return it().inside(); }
 
    bool boundary () const { return it().boundary(); }
 
    bool neighbor () const { return it().neighbor(); }
 
    int boundaryId () const { return it().boundaryId(); }
 
    size_t boundarySegmentIndex() const { return it().boundarySegmentIndex(); }
 
    LocalGeometry geometryInInside () const
    {
      return it().geometryInInside();
    }
 
    Geometry geometry () const
    {
      return it().geometry();
    }
 
    GeometryType type () const
    {
      return it().type();
    }
 
    int indexInInside () const
    {
      return it().indexInInside();
    }
 
    LocalGeometry geometryInOutside () const
    {
      return it().geometryInOutside();
    }
 
    int indexInOutside () const
    {
      return it().indexInOutside();
    }
 
    int twistInSelf() const { return it().twistInSelf(); }
 
    int twistInInside() const { return it().twistInInside(); }
 
    int twistInNeighbor() const { return it().twistInNeighbor(); }
 
    int twistInOutside() const { return it().twistInOutside(); }
 
    const NormalType unitOuterNormal ( const FieldVector< ctype, dim-1 > &local ) const
    {
      return it().unitOuterNormal( local );
    }
 
    const NormalType centerUnitOuterNormal ( ) const
    {
      GeometryType type = geometry().type();
      const ReferenceElement<ctype, dim-1> & refElement =
        ReferenceElements<ctype, dim-1>::general(type);
      return unitOuterNormal(refElement.position(0,0));
    }
 
    const NormalType outerNormal ( const FieldVector< ctype, dim-1 > &local ) const
    {
      return it().outerNormal( local );
    }
 
    const NormalType integrationOuterNormal ( const FieldVector< ctype, dim-1 > &local ) const
    {
      return it().integrationOuterNormal( local );
    }
 
    int level () const { return it().level(); }
 
    bool conforming () const { return it().conforming(); }
 
    IntersectionIteratorImp & it() { return it_; }
    const IntersectionIteratorImp & it() const { return it_; }
 
  private:
    const FactoryType& factory_ ;
    IntersectionIteratorImp & it_;
  }; // end class IntersectionIteratorWrapper
 
  template <class GridImp>
  class LeafIntersectionWrapper
    : public IntersectionIteratorWrapper<GridImp,typename GridImp::LeafIntersectionIteratorImp>
  {
    typedef LeafIntersectionWrapper<GridImp> ThisType;
    typedef IntersectionIteratorWrapper<GridImp,typename GridImp::LeafIntersectionIteratorImp> BaseType;
  public:
    template <class EntityImp>
    LeafIntersectionWrapper(const EntityImp & en, int wLevel , bool end )
      : BaseType(en,wLevel,end)
    {}
 
    LeafIntersectionWrapper(const ThisType & org)
      : BaseType(org)
    {}
 
  };
 
  template <class GridImp>
  class LeafIntersectionIteratorWrapper
  {
    typedef LeafIntersectionIteratorWrapper<GridImp> ThisType;
    typedef LeafIntersectionWrapper<GridImp> IntersectionImp;
 
  public:
    typedef Dune::Intersection< GridImp, IntersectionImp > Intersection;
 
    enum { dimension      = GridImp :: dimension  };
    enum { dimensionworld = GridImp :: dimensionworld };
 
    typedef typename GridImp :: ctype ctype;
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
    typedef FieldVector<ctype , dimensionworld> NormalType;
 
    template <class EntityImp>
    LeafIntersectionIteratorWrapper(const EntityImp & en, int wLevel , bool end )
      : intersection_( IntersectionImp(en,wLevel,end) )
    {}
 
    LeafIntersectionIteratorWrapper(const ThisType & org)
      : intersection_( IntersectionImp( org.impl() ) )
    {}
 
    ThisType & operator = (const ThisType & org)
    {
      impl() = org.impl();
      return *this;
    }
 
    const Intersection &dereference () const
    {
      return intersection_;
    }
 
    bool equals (const ThisType & i) const { return impl().equals( i.impl() ); }
 
    void increment()
    {
      impl().increment();
    }
  protected:
    // intersection object
    Intersection intersection_;
 
    // return reference to real implementation
    IntersectionImp& impl() { return GridImp :: getRealImplementation( intersection_ ); }
    // return reference to real implementation
    const IntersectionImp& impl() const { return GridImp :: getRealImplementation( intersection_ ); }
  }; // end class IntersectionIteratorWrapper
 
  template <class GridImp>
  class LevelIntersectionWrapper
    : public IntersectionIteratorWrapper<GridImp,typename GridImp::LevelIntersectionIteratorImp>
  {
    typedef LevelIntersectionWrapper<GridImp> ThisType;
    typedef IntersectionIteratorWrapper<GridImp,typename GridImp::LevelIntersectionIteratorImp> BaseType;
  public:
    template <class EntityImp>
    LevelIntersectionWrapper(const EntityImp & en, int wLevel , bool end )
      : BaseType(en,wLevel,end)
    {}
 
    LevelIntersectionWrapper(const ThisType & org)
      : BaseType(org)
    {}
  };
 
  template <class GridImp>
  class LevelIntersectionIteratorWrapper
  {
    typedef LevelIntersectionIteratorWrapper<GridImp> ThisType;
    typedef LevelIntersectionWrapper<GridImp> IntersectionImp;
  public:
    typedef Dune::Intersection< GridImp, IntersectionImp > Intersection;
 
    enum { dimension      = GridImp :: dimension  };
    enum { dimensionworld = GridImp :: dimensionworld };
 
    typedef typename GridImp :: ctype ctype;
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    typedef typename GridImp::template Codim<1>::Geometry Geometry;
    typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
    typedef FieldVector<ctype , dimensionworld> NormalType;
 
    template <class EntityImp>
    LevelIntersectionIteratorWrapper(const EntityImp & en, int wLevel , bool end )
      : intersection_( IntersectionImp(en,wLevel,end) )
    {}
 
    LevelIntersectionIteratorWrapper(const ThisType & org)
      : intersection_( IntersectionImp( org.impl() ) )
    {}
 
    ThisType & operator = (const ThisType & org)
    {
      impl() = org.impl();
      return *this;
    }
 
    const Intersection &dereference () const
    {
      return intersection_;
    }
 
    bool equals (const ThisType & i) const { return impl().equals( i.impl() ); }
 
    void increment()
    {
      impl().increment();
    }
  protected:
    // intersection object
    Intersection intersection_;
 
    // return reference to real implementation
    IntersectionImp& impl() { return GridImp :: getRealImplementation( intersection_ ); }
    // return reference to real implementation
    const IntersectionImp& impl() const { return GridImp :: getRealImplementation( intersection_ ); }
  }; // end class IntersectionIteratorWrapper
 
} // end namespace Dune
#endif