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