hostgridaccess.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 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_HOSTGRIDACCESS_HH
#define DUNE_GRID_HOSTGRIDACCESS_HH
 
#include <string>
 
#include <dune/grid/geometrygrid/intersection.hh>
 
namespace Dune
{
 
  // External Forward Declarations
  // -----------------------------
 
  template< class HostGrid, class CoordFunction, class Allocator >
  class GeometryGrid;
 
  template< class >
  class IdentityGrid;
 
 
  // HostGridAccess
  // --------------
 
  template< class Grid >
  struct HostGridAccess;
 
 
 
  template< class HG, class CoordFunction, class Allocator >
  struct HostGridAccess< GeometryGrid< HG, CoordFunction, Allocator > >
  {
    typedef GeometryGrid< HG, CoordFunction, Allocator > Grid;
 
    typedef typename Grid::HostGrid HostGrid;
 
    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::Entity Entity;
 
      typedef typename HostGrid::template Codim< codim >::Entity HostEntity;
    };
 
    typedef typename Grid::Traits::LeafIntersection LeafIntersection;
    typedef typename Grid::Traits::LevelIntersection LevelIntersection;
 
    typedef typename HostGrid::Traits::LeafIntersection HostLeafIntersection;
    typedef typename HostGrid::Traits::LevelIntersection HostLevelIntersection;
 
    static const HostGrid &hostGrid ( const Grid &grid )
    {
      return grid.hostGrid();
    }
 
    template< class Entity >
    static const typename Codim< Entity::codimension >::HostEntity &
    hostEntity ( const Entity &entity )
    {
      return hostEntity< Entity::codimension >( entity );
    }
 
    template< int codim >
    static const typename Codim< codim >::HostEntity &
    hostEntity ( const typename Codim< codim >::Entity &entity )
    {
      return entity.impl().hostEntity();
    }
 
    template< class HostIntersection >
    static const HostIntersection &
    hostIntersection ( const Intersection< const Grid, GeoGrid::Intersection< const Grid, HostIntersection > > &intersection )
    {
      return intersection.impl().hostIntersection();
    }
  };
 
 
  template< class HG >
  struct HostGridAccess< IdentityGrid< HG > >
  {
    typedef IdentityGrid< HG > Grid;
 
    typedef HG HostGrid;
 
    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::Entity Entity;
 
      typedef typename HostGrid::template Codim< codim >::Entity HostEntity;
    };
 
    typedef typename Grid::Traits::LeafIntersection LeafIntersection;
    typedef typename Grid::Traits::LevelIntersection LevelIntersection;
 
    typedef typename HostGrid::Traits::LeafIntersection HostLeafIntersection;
    typedef typename HostGrid::Traits::LevelIntersection HostLevelIntersection;
 
    static const HostGrid &hostGrid ( const Grid &grid )
    {
      return grid.getHostGrid();
    }
 
    template< class Entity >
    static const typename Codim< Entity::codimension >::HostEntity &
    hostEntity ( const Entity &entity )
    {
      return hostEntity< Entity::codimension >( entity );
    }
 
    template< int codim >
    static const typename Codim< codim >::HostEntity &
    hostEntity ( const typename Codim< codim >::Entity &entity )
    {
      return *entity.impl().hostEntity_;
    }
 
    static const HostLeafIntersection &
    hostIntersection ( const LeafIntersection &intersection )
    {
      return *intersection.impl().hostIterator_;
    }
 
    static const HostLevelIntersection &
    hostIntersection ( const LevelIntersection &intersection )
    {
      return *intersection.impl().hostIterator_;
    }
  };
 
} // namespace Dune
 
#endif // #ifndef DUNE_GRID_HOSTGRIDACCESS_HH