geometrytypemap.hh

#ifndef DUNE_FEM_COMMON_GEOMETRYTYPEMAP_HH
#define DUNE_FEM_COMMON_GEOMETRYTYPEMAP_HH
 
#include <array>
#include <type_traits>
#include <utility>
 
#include <dune/geometry/type.hh>
#include <dune/geometry/typeindex.hh>
 
namespace Dune
{
 
  // GeometryTypeMap
  // ---------------
 
  template< class T, int dim, class TypeIndex >
  class GeometryTypeMap
  {
    typedef GeometryTypeMap< T, dim, TypeIndex > This;
    typedef std::array< T, TypeIndex::size( dim ) > Container;
 
  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;
 
    GeometryTypeMap () : container_() {}
 
    GeometryTypeMap ( const This & ) = default;
 
    GeometryTypeMap ( This && ) = default;
 
    This &operator= ( const This & ) = default;
 
    This &operator= ( This && ) = default;
 
    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(); }
 
    constexpr Size size () const noexcept { return TypeIndex::size( dim ); }
    constexpr Size max_size () const noexcept { return size(); }
    constexpr bool empty () const noexcept { return (size() > 0); }
 
    Value &operator[] ( const GeometryType &type ) { return container_[ TypeIndex::index( type ) ]; }
    const Value &operator[] ( const GeometryType &type ) const { return container_[ TypeIndex::index( type ) ]; }
 
    Value &at ( const GeometryType &type ) { return container_.at( TypeIndex::index( type ) ); }
    const Value &at ( const GeometryType &type ) const { return container_.at( TypeIndex::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 >
  using LocalGeometryTypeMap = GeometryTypeMap< T, dim, LocalGeometryTypeIndex >;
 
 
 
  // GlobalGeometryTypeMap
  // ---------------------
 
  template< class T, int maxdim >
  using GlobalGeometryTypeMap = GeometryTypeMap< T, maxdim, GlobalGeometryTypeIndex >;
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_COMMON_GEOMETRYTYPEMAP_HH