typemap.hh

#ifndef DUNE_GEOMETRY_TYPEMAP_HH
#define DUNE_GEOMETRY_TYPEMAP_HH
 
#include <array>
#include <utility>
 
#include <dune/geometry/type.hh>
 
#include "typeindexset.hh"
 
namespace Dune
{
 
  namespace Fem {
 
    namespace hpDG {
 
  // GeometryTypeMap
  // ---------------
 
  template< class T, class TypeIndexSet >
  class GeometryTypeMap
    : private TypeIndexSet
  {
    typedef GeometryTypeMap< T, TypeIndexSet > This;
    typedef std::array< T, TypeIndexSet::size() > Container;
 
    using TypeIndexSet::index;
 
  public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::pointer pointer;
    typedef typename Container::const_pointer const_pointer;
    typedef typename Container::iterator iterator;
    typedef typename Container::const_iterator const_iterator;
    typedef typename Container::size_type size_type;
    typedef typename Container::difference_type difference_type;
 
    typedef value_type Value;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    typedef size_type Size;
 
    Iterator begin () noexcept { return container_.begin(); }
    Iterator end () noexcept { return container_.end(); }
    ConstIterator begin () const noexcept { return container_.begin(); }
    ConstIterator end () const noexcept { return container_.end(); }
 
    ConstIterator cbegin () const noexcept { return container_.cbegin(); }
    ConstIterator cend () const noexcept { return container_.cend(); }
 
    GeometryType type ( Iterator iterator ) const
    {
      return type( static_cast< ConstIterator >( iterator ) );
    }
 
    GeometryType type ( ConstIterator iterator ) const
    {
      return TypeIndexSet::type( iterator - begin() );
    }
 
    static constexpr Size size () noexcept { return TypeIndexSet::size(); }
    static constexpr Size max_size () noexcept { return size(); }
    static constexpr bool empty () noexcept { return (size() > 0); }
 
    Value &operator[] ( const GeometryType &type ) { return container_[ index( type ) ]; }
    const Value &operator[] ( const GeometryType &type ) const { return container_[ index( type ) ]; }
 
    Value &at ( const GeometryType &type ) { return container_.at( index( type ) ); }
    const Value &at ( const GeometryType &type ) const { return container_.at( index( type ) ); }
 
    Value &front () { return container_.front(); }
    const Value &front () const { return container_.front(); }
 
    Value &back () { return container_.back(); }
    const Value &back () const { return container_.back(); }
 
    Value *data () noexcept { return container_.data(); }
    const Value *data () const noexcept { return container_.data(); }
 
    void fill ( const Value &value ) { container_.fill( value ); }
 
    void swap ( This &other ) noexcept(noexcept(swap(std::declval<Value &>(), std::declval<Value &>())))
    {
      container_.swap( other.container_ );
    }
 
  private:
    Container container_;
  };
 
 
 
  // LocalGeometryTypeMap
  // --------------------
 
  template< class T, int dim, bool regular = false >
  struct LocalGeometryTypeMap
    : public GeometryTypeMap< T, LocalGeometryTypeIndexSet< dim, regular > >
  {};
 
 
 
  // GlobalGeometryTypeMap
  // ---------------------
 
  template< class T, int maxdim, bool regular = false >
  struct GlobalGeometryTypeMap
    : public GeometryTypeMap< T, GlobalGeometryTypeIndexSet< maxdim, regular > >
  {};
 
} // namespace hpDG
} // namespace Fem
} // namespace Dune
 
#endif // #ifndef DUNE_GEOMETRY_TYPEMAP_HH