indexset.hh

#ifndef DUNE_FEM_GRIDPART_COMMON_INDEXSET_HH
#define DUNE_FEM_GRIDPART_COMMON_INDEXSET_HH
 
#include <type_traits>
#include <utility>
#include <vector>
 
#include <dune/geometry/type.hh>
 
#include <dune/fem/io/streams/streams.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Internal forward declaration
    // ----------------------------
    template< class Traits >
    class IndexSet;
    template< class Traits >
    class ConsecutiveIndexSet;
    template< class Traits >
    class AdaptiveIndexSet;
 
 
    namespace Capabilities
    {
 
      template< class IndexSet >
      struct isDuneFemIndexSet
      {
        template< class Traits >
        static std::true_type __isDuneFemIndexSet ( const Dune::Fem::IndexSet< Traits > & );
 
        static std::false_type __isDuneFemIndexSet ( ... );
 
      public:
        static const bool v = decltype( __isDuneFemIndexSet( std::declval< IndexSet >() ) )::value;
      };
 
 
      // isConsecutiveIndexSet
      // ---------------------
 
      template< class IndexSet >
      struct isConsecutiveIndexSet
      {
        template< class Traits >
        static std::true_type __isConsecutive ( const ConsecutiveIndexSet< Traits > & );
 
        static std::false_type __isConsecutive ( ... );
 
      public:
        static const bool v = decltype( __isConsecutive( std::declval< IndexSet >() ) )::value;
      };
 
 
      // isAdaptiveIndexSet
      // ------------------
 
      template< class IndexSet >
      class isAdaptiveIndexSet
      {
        template< class Traits >
        static std::true_type __isAdaptive ( const AdaptiveIndexSet< Traits > & );
 
        static std::false_type __isAdaptive ( ... );
 
      public:
        static const bool v = decltype( __isAdaptive( std::declval< IndexSet >() ) )::value;
      };
 
 
 
#ifndef DOXYGEN
 
      template< class IndexSet >
      struct isConsecutiveIndexSet< const IndexSet >
        : public isConsecutiveIndexSet< IndexSet >
      {};
 
      template< class IndexSet >
      struct isAdaptiveIndexSet< const IndexSet >
        : public isAdaptiveIndexSet< IndexSet >
      {};
 
#endif // #ifndef DOXYGEN
 
    } // namespace Capabilites
 
 
 
    // IndexSet
    // --------
 
    template< class Traits >
    class IndexSet
    {
    public:
      static const int dimension = Traits::dimension;
 
      template< int codim >
      struct Codim
      {
        typedef typename Traits::template Codim< codim >::Entity Entity;
      };
 
      typedef typename Traits::IndexType IndexType;
 
      typedef typename Traits::Types Types;
 
    protected:
      IndexSet () = default;
 
    public:
      Types types ( int codim ) const
      {
        return impl().types( codim );
      }
 
      template< class Entity >
      bool contains ( const Entity &entity ) const
      {
        return impl().contains( entity );
      }
 
      IndexType size ( GeometryType type ) const
      {
        return impl().size( type );
      }
 
      IndexType size ( int codim ) const
      {
        return impl().size( codim );
      }
 
      template< class Entity >
      IndexType index ( const Entity &entity ) const
      {
        return index< Entity::codimension >( entity );
      }
 
      template< int codim >
      IndexType index ( const typename Codim< codim >::Entity &entity ) const
      {
        return impl().template index< codim >( entity );
      }
 
      template< class Entity >
      IndexType subIndex ( const Entity &entity, int i, unsigned int cd ) const
      {
        return subIndex< Entity::codimension >( entity, i, cd );
      }
 
      template< int codim >
      IndexType subIndex ( const typename Codim< codim >::Entity &entity, int i, unsigned int cd ) const
      {
        return impl().template subIndex< codim >( entity, i, cd );
      }
 
      void requestCodimensions ( const std::vector< int >& codimensions ) const
      {
      }
 
    protected:
      const typename Traits::IndexSetType &impl () const
      {
        return static_cast< const typename Traits::IndexSetType & >( *this );
      }
    };
 
    // ConsecutiveIndexSet
    // -------------------
 
    template< class Traits >
    class ConsecutiveIndexSet
      : public IndexSet< Traits >
    {
      typedef IndexSet< Traits > BaseType;
 
    protected:
      using BaseType::impl;
 
      ConsecutiveIndexSet () = default;
 
    public:
      void resize () { impl().resize(); }
 
      bool compress () { return impl().compress(); }
 
      void insertEntity ( const typename BaseType::template Codim< 0 >::Entity &entity )
      {
        impl().insertEntity( entity );
      }
 
      void removeEntity ( const typename BaseType::template Codim< 0 >::Entity &entity )
      {
        impl().removeEntity( entity );
      }
 
      void backup () const { impl().backup(); }
 
      void restore () { impl().restore(); }
 
      template< class T >
      void write ( OutStreamInterface< T > &stream ) const
      {
        impl().write( stream );
      }
 
      template< class T >
      void read ( InStreamInterface< T > &stream )
      {
        impl().read( stream );
      }
 
    protected:
      typename Traits::IndexSetType &impl ()
      {
        const typename Traits::IndexSetType &impl = BaseType::impl();
        return const_cast< typename Traits::IndexSetType & >( impl );
      }
    };
 
 
 
    // AdaptiveIndexSet
    // ----------------
 
    template< class Traits >
    class AdaptiveIndexSet
      : public ConsecutiveIndexSet< Traits >
    {
      typedef ConsecutiveIndexSet< Traits > BaseType;
 
    protected:
      using BaseType::impl;
 
      AdaptiveIndexSet () = default;
 
    public:
      int numberOfHoles ( GeometryType type ) const
      {
        return impl().numberOfHoles( type );
      }
 
      int oldIndex ( int hole, GeometryType type ) const
      {
        return impl().oldIndex( hole, type );
      }
 
      int newIndex ( int hole, GeometryType type ) const
      {
        return impl().newIndex( hole, type );
      }
 
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_GRIDPART_COMMON_INDEXSET_HH