common/indexidset.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_INDEXIDSET_HH
#define DUNE_GRID_COMMON_INDEXIDSET_HH
 
#include <vector>
#include <dune/common/exceptions.hh>
#include <dune/grid/common/grid.hh>
 
 
namespace Dune
{
 
#include <dune/common/bartonnackmanifcheck.hh>
 
  template< class GridImp, class IndexSetImp, class IndexTypeImp, class TypesImp >
  class IndexSet
  {
    /* We use the remove_const to extract the Type from the mutable class,
       because the const class is not instantiated yet. */
    typedef typename std::remove_const< GridImp >::type::Traits Traits;
 
  public:
    template <int cc>
    struct Codim
    {
      typedef typename Traits :: template Codim<cc> :: Entity Entity;
    };
 
    typedef IndexTypeImp IndexType;
 
    typedef TypesImp Types;
 
    static const int dimension = std::remove_const< GridImp >::type::dimension;
 
    //===========================================================
    //===========================================================
 
    template<int cc>
    IndexType index (const typename Traits::template Codim<cc>::Entity& e) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template index<cc>(e)));
      return asImp().template index<cc>(e);
    }
 
    template<class Entity>
    IndexType index (const Entity& e) const
    {
      constexpr static int cc = Entity::codimension;
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template index<cc>(e)));
      return asImp().template index<cc>(e);
    }
 
    template< int cc >
    IndexType subIndex ( const typename Traits::template Codim< cc >::Entity &e,
                         int i, unsigned int codim ) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template subIndex< cc >(e,i,codim)));
      return asImp().template subIndex< cc >(e,i,codim);
    }
 
    template< class Entity >
    IndexType subIndex ( const Entity &e, int i, unsigned int codim ) const
    {
      static const int cc = Entity::codimension;
      return asImp().template subIndex< cc >( e, i, codim );
    }
 
 
    //===========================================================
    //===========================================================
 
    Types types ( int codim ) const
    {
      CHECK_INTERFACE_IMPLEMENTATION( (asImp().types( codim )) );
      return asImp().types( codim );
    }
 
    auto size (GeometryType type) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().size(type)));
      return asImp().size(type);
    }
 
    auto size (int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().size(codim)));
      return asImp().size(codim);
    }
 
    template<class Entity>
    bool contains (const Entity& e) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().contains(e)));
      return asImp().contains(e);
    }
 
  protected:
    // Must be explicitly defined although this class should get a default constructor.
    IndexSet() = default;
 
  public:
    IndexSet(const IndexSet&) = delete;
    IndexSet& operator=(const IndexSet&) = delete;
 
  private:
    IndexSetImp& asImp () {return static_cast<IndexSetImp &> (*this);}
    const IndexSetImp& asImp () const {return static_cast<const IndexSetImp &>(*this);}
  };
 
#undef CHECK_INTERFACE_IMPLEMENTATION
#undef CHECK_AND_CALL_INTERFACE_IMPLEMENTATION
 
 
 
  template<class GridImp, class IndexSetImp>
  class IndexSetDefaultImplementation
    : public IndexSet< GridImp, IndexSetImp >
  {
    typedef IndexSet< GridImp, IndexSetImp > Base;
    typedef typename std::remove_const< GridImp >::type::Traits Traits;
 
  public:
    typedef typename Base::IndexType IndexType;
 
    typedef typename Base::Types Types;
 
    static const int dimension = Base::dimension;
 
    using Base::index;
    using Base::subIndex;
 
    //===========================================================
    //===========================================================
 
    Types types ( int codim ) const { return asImp().geomTypes( codim ); }
 
    auto size ( const int codim ) const
    {
      using SizeType = std::decay_t<decltype( Base::size( Dune::GeometryType() ) )>;
 
      SizeType s ( 0 );
      for(GeometryType gt : types(codim))
        s += Base::size(gt);
 
      return s;
    }
 
  private:
    IndexSetImp &asImp () { return static_cast< IndexSetImp & >( *this );}
    const IndexSetImp &asImp () const { return static_cast< const IndexSetImp & >( *this ); }
  };
 
 
  template<class GridImp, class IdSetImp, class IdTypeImp>
  class IdSet
  {
    /* We use the remove_const to extract the Type from the mutable class,
       because the const class is not instantiated yet. */
    using Traits = typename std::remove_const< GridImp >::type::Traits;
  public:
    typedef IdTypeImp IdType;
 
    template <int cc>
    struct Codim {
      using Entity = typename Traits::template Codim<cc>::Entity;
    };
 
    static constexpr auto dimension = std::remove_const< GridImp >::type::dimension;
 
    template<class Entity>
    IdType id (const Entity& e) const
    {
      constexpr static int cc = Entity::codimension;
      return asImp().template id<cc>(e);
    }
 
    template<int cc>
    IdType id (const typename Codim<cc>::Entity& e) const
    {
      return asImp().template id<cc>(e);
    }
 
    IdType subId (const typename Codim<0>::Entity& e, int i, unsigned int codim) const
    {
      return asImp().subId(e,i,codim);
    }
 
  protected:
    // Default constructor (is not provided automatically because copy constructor is private)
    IdSet() = default;
 
  public:
    IdSet(const IdSet&) = delete;
    IdSet& operator=(const IdSet&) = delete;
 
  private:
    IdSetImp& asImp () {return static_cast<IdSetImp &> (*this);}
    const IdSetImp& asImp () const {return static_cast<const IdSetImp &>(*this);}
  };
 
}
 
#endif   // DUNE_GRID_COMMON_INDEXIDSET_HH