README.md

@@ -28,7 +28,7 @@ dune-common depends on the following software packages
   icc (C/C++) >= 13.0
   Clang >= 3.2
 
-The following software is recommend but optional:
+The following software is recommended but optional:
 
 - MPI (either OpenMPI, lam, or mpich suffice)
 

dune/common/densevector.hh

@@ -284,18 +284,18 @@ namespace Dune {
     //! random access
     value_type & operator[] (size_type i)
     {
-      return asImp().vec_access(i);
+      return asImp()[i];
     }
 
     const value_type & operator[] (size_type i) const
     {
-      return asImp().vec_access(i);
+      return asImp()[i];
     }
 
     //! size method
     size_type size() const
     {
-      return asImp().vec_size();
+      return asImp().size();
     }
 
     //! Iterator class for sequential access

dune/common/dynvector.hh

@@ -137,9 +137,9 @@ namespace Dune {
     }
 
     //==== make this thing a vector
-    size_type vec_size() const { return _data.size(); }
-    K & vec_access(size_type i) { return _data[i]; }
-    const K & vec_access(size_type i) const { return _data[i]; }
+    size_type size() const { return _data.size(); }
+    K & operator[](size_type i) { return _data[i]; }
+    const K & operator[](size_type i) const { return _data[i]; }
   };
 
   /** \brief Read a DynamicVector from an input stream

dune/common/fvector.hh

@@ -158,12 +158,10 @@ namespace Dune {
     }
     using Base::operator=;
 
-    DUNE_CONSTEXPR size_type size () const { return vec_size(); }
-
     // make this thing a vector
-    DUNE_CONSTEXPR size_type vec_size () const { return SIZE; }
-    K & vec_access(size_type i) { return _data[i]; }
-    const K & vec_access(size_type i) const { return _data[i]; }
+    DUNE_CONSTEXPR size_type size () const { return SIZE; }
+    K & operator[](size_type i) { return _data[i]; }
+    const K & operator[](size_type i) const { return _data[i]; }
   private:
     void fill(const K& t)
     {
@@ -266,17 +264,15 @@ namespace Dune {
       return *this;
     }
 
-    DUNE_CONSTEXPR size_type size () const { return vec_size(); }
-
     //===== forward methods to container
-    DUNE_CONSTEXPR size_type vec_size () const { return 1; }
-    K & vec_access(size_type i)
+    DUNE_CONSTEXPR size_type size () const { return 1; }
+    K & operator[](size_type i)
     {
       DUNE_UNUSED_PARAMETER(i);
       assert(i == 0);
       return _data;
     }
-    const K & vec_access(size_type i) const
+    const K & operator[](size_type i) const
     {
       DUNE_UNUSED_PARAMETER(i);
       assert(i == 0);

dune/common/typetraits.hh

@@ -531,6 +531,38 @@ namespace Dune
 
 #endif // defined(DOXYGEN) or HAVE_IS_INDEXABLE_SUPPORT
 
+  namespace detail
+  {
+    ///
+    /**
+     * @internal
+     * @brief Helper to make void_t work with gcc versions prior to gcc 5.0.
+     *
+     * This was not a compiler bug, but an accidental omission in the C++11 standard (see N3911, CWG issue 1558).
+     * It is not clearly specified what happens
+     * with unused template arguments in template aliases. The developers of GCC decided to ignore them, thus making void_t equivalent to void.
+     * With gcc 5.0 this was changed and the voider-hack is no longer needed.
+     */
+    template <class...>
+    struct voider
+    {
+      using type = void;
+    };
+  }
+
+  template <class> struct FieldTraits;
+
+  //! Is void for all valid input types (see N3911). The workhorse for C++11 SFINAE-techniques.
+  template <class... Types>
+  using void_t = typename detail::voider<Types...>::type;
+
+  //! Convenient access to FieldTraits<Type>::field_type.
+  template <class Type>
+  using field_t = typename FieldTraits<Type>::field_type;
+
+  //! Convenient access to FieldTraits<Type>::real_type.
+  template <class Type>
+  using real_t = typename FieldTraits<Type>::real_type;
 
   /** @} */
 }