common/gridview.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_GRIDVIEW_HH
#define DUNE_GRID_COMMON_GRIDVIEW_HH

#include <typeinfo>

#include <dune/common/std/type_traits.hh>
#include <dune/common/iteratorrange.hh>
#include <dune/common/parallel/future.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;

  public:
    typedef typename ViewTraits :: GridViewImp Implementation;

    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;

    using Communication = typename Traits :: Communication;

    template< int cd >
    struct Codim {
      typedef typename Traits :: template Codim<cd> :: Iterator Iterator;

      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> {};

    constexpr static bool conforming = Traits :: conforming;

    typedef typename Grid::ctype ctype;

    constexpr static int dimension = Grid :: dimension;

    constexpr static int 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 );
    }

  private:

    template<class I>
    using HasIsConformingMethod = decltype(std::declval<I>().isConforming());

  public:

    bool isConforming () const
    {
      // if implementation provides a method isConforming, call it
      if constexpr (Std::is_detected_v<HasIsConformingMethod, Implementation>)
      {
        return impl().isConforming();
      }
      else
      {
        // otherwise default to static conforming flag
        return bool(conforming);
      }
    }

    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 Communication &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 >
    auto communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir ) const
    {
      typedef decltype( impl().communicate(data,iftype,dir) ) CommFuture;
      return communicate( data,iftype, dir,
            std::integral_constant< bool, std::is_same< CommFuture, void > :: value >() );
    }

    Implementation &impl () { return impl_; }

    const Implementation &impl () const { return impl_; }

  protected:
    template< class DataHandleImp, class DataType >
    auto communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir, std::integral_constant< bool, false > ) const
    {
      return impl().communicate(data,iftype,dir);
    }

    struct DeprecatedMethodEmptyFuture : public Future<void>
    {
      void printMessage() const
      {
        std::cerr << "WARNING: GridView::communicate of '" <<
          typeid( Implementation ).name() << "' still returns void. Please update implementation to new interface returning a future object!" << std::endl;
      }

      bool ready () {
        printMessage();
        return true;
      }
      void wait () { printMessage(); }
      bool valid () const { printMessage(); return true; }
    };

    template< class DataHandleImp, class DataType >
    auto communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir, std::integral_constant< bool, true > ) const
    {
      impl().communicate(data,iftype,dir);
      return DeprecatedMethodEmptyFuture();
    }

    Implementation impl_;
  };

} // namespace Dune

#endif // #ifndef DUNE_GRID_COMMON_GRIDVIEW_HH