gridview.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRIDVIEW_HH
#define DUNE_GRIDVIEW_HH
 
#include <dune/common/iteratorrange.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/grid/common/datahandleif.hh>
#include <dune/grid/common/rangegenerators.hh>
 
namespace Dune
{
 
  template< int, int, class, class >
  class GridDefaultImplementation;
 
 
 
  template< class ViewTraits >
  class GridView
  {
    typedef GridView< ViewTraits > ThisType;
 
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
  public:
#else
  protected:
#endif
    // type of underlying implementation, for internal use only
    typedef typename ViewTraits :: GridViewImp Implementation;
 
  public:
    typedef typename ViewTraits :: GridViewImp GridViewImp;
 
    typedef ViewTraits Traits;
 
    typedef typename Traits :: Grid Grid;
 
    typedef typename Traits :: IndexSet IndexSet;
 
    typedef typename Traits :: Intersection Intersection;
 
    typedef typename Traits :: IntersectionIterator IntersectionIterator;
 
    typedef typename Traits :: CollectiveCommunication CollectiveCommunication;
 
    template< int cd >
    struct Codim {
      typedef typename Traits :: template Codim<cd> :: Iterator Iterator;
 
      typedef typename Traits :: template Codim<cd> :: EntityPointer EntityPointer;
 
      typedef typename Traits :: template Codim<cd> :: Entity Entity;
 
      typedef typename Traits :: template Codim<cd> :: Geometry Geometry;
 
      typedef typename Traits :: template Codim<cd> :: LocalGeometry LocalGeometry;
 
      template< PartitionIteratorType pit >
      struct Partition
      {
        typedef typename Traits :: template Codim< cd >
        :: template Partition< pit > :: Iterator Iterator;
      };
    }; //: public Traits :: template Codim<cd> {};
 
    enum {
      conforming = Traits :: conforming
    };
 
    typedef typename Grid::ctype ctype;
 
    enum { 
      dimension = Grid :: dimension
    };
 
    enum { 
      dimensionworld = Grid :: dimensionworld
    };
 
  public:
 
    //===========================================================
    //===========================================================
    GridView ( const Implementation &imp )
      : impl_( imp )
    {}
 
    GridView ( const ThisType &other )
      : impl_( other.impl_ )
    {}
 
    ThisType &operator= ( const ThisType &other )
    {
      impl_ = other.impl_;
      return *this;
    }
 
  public:
    const Grid &grid () const
    {
      return impl().grid();
    }
 
    const IndexSet &indexSet () const
    {
      return impl().indexSet();
    }
 
    int size ( int codim ) const
    {
      return impl().size( codim );
    }
 
    int size ( const GeometryType &type ) const
    {
      return impl().size( type );
    }
 
    template<class EntityType>
    bool contains (const EntityType& e) const
    {
      return impl().indexSet().contains(e);
    }
 
    template< int cd >
    typename Codim< cd > :: Iterator begin () const
    {
      return impl().template begin<cd>();
    }
 
    template< int cd >
    typename Codim< cd > :: Iterator end () const
    {
      return impl().template end<cd>();
    }
 
    template< int cd , PartitionIteratorType pitype >
    typename Codim< cd > :: template Partition< pitype > :: Iterator
    begin () const
    {
      return impl().template begin<cd,pitype>();
    }
 
    template< int cd, PartitionIteratorType pitype >
    typename Codim< cd > :: template Partition< pitype > :: Iterator
    end () const
    {
      return impl().template end<cd,pitype>();
    }
 
    IntersectionIterator
    ibegin ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return impl().ibegin(entity);
    }
 
    IntersectionIterator
    iend ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return impl().iend(entity);
    }
 
    const CollectiveCommunication &comm () const
    {
      return impl().comm();
    }
 
    int overlapSize(int codim) const
    {
      return impl().overlapSize(codim);
    }
 
    int ghostSize(int codim) const
    {
      return impl().ghostSize(codim);
    }
 
    template< class DataHandleImp, class DataType >
    void communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir ) const
    {
      impl().communicate(data,iftype,dir);
    }
 
#if DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
  public:
#else
  protected:
    // give the GridDefaultImplementation class access to the realImp
    friend class GridDefaultImplementation< Grid::dimension, Grid::dimensionworld, typename Grid::ctype, typename Grid::GridFamily >;
#endif
    Implementation &impl () { return impl_; }
    const Implementation &impl () const { return impl_; }
 
  protected:
    Implementation impl_;
  };
 
} // namespace Dune
 
#endif // #ifndef DUNE_GRIDVIEW_HH