// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_CURVED_SURFACE_GRID_CAPABILITIES_HH
#define DUNE_CURVED_SURFACE_GRID_CAPABILITIES_HH

#include <cassert>

#include <dune/common/hybridutilities.hh>
#include <dune/common/std/utility.hh>

#include <dune/grid/common/capabilities.hh>
#include <dune/grid/geometrygrid/capabilities.hh>
#include <dune/curvedsurfacegrid/declaration.hh>
#include <dune/curvedsurfacegrid/gridfunctions/gridfunction.hh>

namespace Dune
{

  // Capabilities
  // ------------

  namespace Capabilities
  {

    // Capabilities from dune-grid
    // ---------------------------

    template< class GridFunction, int order >
    struct hasSingleGeometryType< CurvedSurfaceGrid<GridFunction,order> >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = hasSingleGeometryType< HostGrid > :: v;
      static const unsigned int topologyId = hasSingleGeometryType< HostGrid > :: topologyId;
    };


    template< class GridFunction, int order, int codim >
    struct hasEntity< CurvedSurfaceGrid<GridFunction,order>, codim >
    {
      static const bool v = true;
    };


    template< class GridFunction, int order, int codim >
    struct hasEntityIterator< CurvedSurfaceGrid<GridFunction,order>, codim >
    {
      static const bool v = true;
    };


    template< class GridFunction, int order, int codim >
    struct canCommunicate< CurvedSurfaceGrid<GridFunction,order>, codim >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = canCommunicate< HostGrid, codim >::v && hasEntity< HostGrid, codim >::v;
    };


    template< class GridFunction, int order >
    struct hasBackupRestoreFacilities< CurvedSurfaceGrid<GridFunction,order> >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = hasBackupRestoreFacilities< HostGrid >::v;
    };

    template< class GridFunction, int order >
    struct isLevelwiseConforming< CurvedSurfaceGrid<GridFunction,order> >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = isLevelwiseConforming< HostGrid >::v;
    };

    template< class GridFunction, int order >
    struct isLeafwiseConforming< CurvedSurfaceGrid<GridFunction,order> >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = isLeafwiseConforming< HostGrid >::v;
    };

    template< class GridFunction, int order >
    struct threadSafe< CurvedSurfaceGrid<GridFunction,order> >
    {
      static const bool v = false;
    };

    template< class GridFunction, int order >
    struct viewThreadSafe< CurvedSurfaceGrid<GridFunction,order> >
    {
      static const bool v = false;
    };



    // hasHostEntity
    // -------------

    template< class GridFunction, int order, int codim >
    struct hasHostEntity< CurvedSurfaceGrid<GridFunction,order>, codim >
    {
      using HostGrid = GridOf_t<GridFunction>;
      static const bool v = hasEntity< HostGrid, codim >::v;
    };

  } // namespace Capabilities

} // namespace Dune

#endif // DUNE_CURVED_SURFACE_GRID_CAPABILITIES_HH