indexidset.hh

Go to the documentation of this file.

// -*- 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
    {
      enum { 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 );
    }
 
    IndexType size (GeometryType type) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().size(type)));
      return asImp().size(type);
    }
 
    IndexType 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);
    }
 
    // Must be explicitly defined although this class should get a default constructor.
    IndexSet() {}
 
  private:
    IndexSet(const IndexSet&);
    IndexSet& operator=(const IndexSet&);
 
    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 ); }
 
    IndexType size ( const int codim ) const
    {
      IndexType s( 0 );
      const std::vector< GeometryType > &geomTs = asImp().geomTypes( codim );
      typedef typename std::vector< GeometryType >::const_iterator Iterator;
      const Iterator end = geomTs.end();
      for( Iterator it = geomTs.begin(); it != end; ++it )
        s += Base::size( *it );
      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
  {
  public:
    typedef IdTypeImp IdType;
 
    template<class Entity>
    IdType id (const Entity& e) const
    {
      enum { cc = Entity::codimension };
      return asImp().template id<cc>(e);
    }
 
    /*
       We use the remove_const to extract the Type from the mutable class,
       because the const class is not instantiated yet.
     */
    template<int cc>
    IdType id (const typename std::remove_const<GridImp>::type::
               Traits::template Codim<cc>::Entity& e) const
    {
      return asImp().template id<cc>(e);
    }
 
    IdType subId (const typename std::remove_const<GridImp>::type::
                  Traits::template Codim<0>::Entity& e, int i, unsigned int codim) const
    {
      return asImp().subId(e,i,codim);
    }
 
    // Default constructor (is not provided automatically because copy constructor is private)
    IdSet() {}
 
  private:
    IdSet(const IdSet&);
    IdSet& operator=(const IdSet&);
 
    IdSetImp& asImp () {return static_cast<IdSetImp &> (*this);}
    const IdSetImp& asImp () const {return static_cast<const IdSetImp &>(*this);}
  };
 
}
 
#endif   // DUNE_GRID_COMMON_INDEXIDSET_HH