diff --git a/include/highfive/bits/H5Converter_misc.hpp b/include/highfive/bits/H5Converter_misc.hpp
index 2f84a7bec..d1ba132c4 100644
--- a/include/highfive/bits/H5Converter_misc.hpp
+++ b/include/highfive/bits/H5Converter_misc.hpp
@@ -69,7 +69,7 @@ struct DeepCopyBuffer {
     using hdf5_type = typename inspector<type>::hdf5_type;
 
     explicit DeepCopyBuffer(const std::vector<size_t>& _dims)
-        : buffer(inspector<T>::getSize(_dims))
+        : buffer(compute_total_size(_dims))
         , dims(_dims) {}
 
     hdf5_type* getPointer() {
diff --git a/include/highfive/bits/H5Inspector_misc.hpp b/include/highfive/bits/H5Inspector_misc.hpp
index b9afe7c69..3f69276c4 100644
--- a/include/highfive/bits/H5Inspector_misc.hpp
+++ b/include/highfive/bits/H5Inspector_misc.hpp
@@ -129,14 +129,12 @@ inspector<T> {
     static constexpr size_t recursive_ndim
     // Is the inner type trivially copyable for optimisation
     // If this value is true: data() is mandatory
-    // If this value is false: getSize, serialize, unserialize are mandatory
+    // If this value is false: serialize, unserialize are mandatory
     static constexpr bool is_trivially_copyable
 
     // Reading:
     // Allocate the value following dims (should be recursive)
     static void prepare(type& val, const std::vector<std::size_t> dims)
-    // Return the size of the vector pass to/from hdf5 from a vector of dims
-    static size_t getSize(const std::vector<size_t>& dims)
     // Return a pointer of the first value of val (for reading)
     static hdf5_type* data(type& val)
     // Take a serialized vector 'in', some dims and copy value to val (for reading)
@@ -169,10 +167,6 @@ struct type_helper {
         return {};
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& /* val */, const std::vector<size_t>& /* dims */) {}
 
     static hdf5_type* data(type& val) {
@@ -308,10 +302,6 @@ struct inspector<std::vector<T>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         val.resize(dims[0]);
         std::vector<size_t> next_dims(dims.begin() + 1, dims.end());
@@ -332,7 +322,7 @@ struct inspector<std::vector<T>> {
     static void serialize(const type& val, const std::vector<size_t>& dims, It m) {
         if (!val.empty()) {
             auto subdims = std::vector<size_t>(dims.begin() + 1, dims.end());
-            size_t subsize = inspector<value_type>::getSize(subdims);
+            size_t subsize = compute_total_size(subdims);
             for (auto&& e: val) {
                 inspector<value_type>::serialize(e, subdims, m);
                 m += subsize;
@@ -366,13 +356,6 @@ struct inspector<std::vector<bool>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        if (dims.size() > 1) {
-            throw DataSpaceException("std::vector<bool> is only 1 dimension.");
-        }
-        return dims[0];
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         if (dims.size() > 1) {
             throw DataSpaceException("std::vector<bool> is only 1 dimension.");
@@ -425,10 +408,6 @@ struct inspector<std::array<T, N>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         if (dims[0] > N) {
             std::ostringstream os;
@@ -453,7 +432,7 @@ struct inspector<std::array<T, N>> {
     template <class It>
     static void serialize(const type& val, const std::vector<size_t>& dims, It m) {
         auto subdims = std::vector<size_t>(dims.begin() + 1, dims.end());
-        size_t subsize = inspector<value_type>::getSize(subdims);
+        size_t subsize = compute_total_size(subdims);
         for (auto& e: val) {
             inspector<value_type>::serialize(e, subdims, m);
             m += subsize;
@@ -555,7 +534,7 @@ struct inspector<T[N]> {
        we will fix it one day */
     static void serialize(const type& val, const std::vector<size_t>& dims, hdf5_type* m) {
         auto subdims = std::vector<size_t>(dims.begin() + 1, dims.end());
-        size_t subsize = inspector<value_type>::getSize(subdims);
+        size_t subsize = compute_total_size(subdims);
         for (size_t i = 0; i < N; ++i) {
             inspector<value_type>::serialize(val[i], subdims, m + i * subsize);
         }
diff --git a/include/highfive/boost.hpp b/include/highfive/boost.hpp
index d389ef5c6..fb8a709c5 100644
--- a/include/highfive/boost.hpp
+++ b/include/highfive/boost.hpp
@@ -31,10 +31,6 @@ struct inspector<boost::multi_array<T, Dims>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         if (dims.size() < ndim) {
             std::ostringstream os;
@@ -67,7 +63,7 @@ struct inspector<boost::multi_array<T, Dims>> {
     static void serialize(const type& val, const std::vector<size_t>& dims, It m) {
         size_t size = val.num_elements();
         auto subdims = std::vector<size_t>(dims.begin() + ndim, dims.end());
-        size_t subsize = inspector<value_type>::getSize(subdims);
+        size_t subsize = compute_total_size(subdims);
         for (size_t i = 0; i < size; ++i) {
             inspector<value_type>::serialize(*(val.origin() + i), subdims, m + i * subsize);
         }
@@ -104,10 +100,6 @@ struct inspector<boost::numeric::ublas::matrix<T>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         if (dims.size() < ndim) {
             std::ostringstream os;
@@ -129,7 +121,7 @@ struct inspector<boost::numeric::ublas::matrix<T>> {
     static void serialize(const type& val, const std::vector<size_t>& dims, hdf5_type* m) {
         size_t size = val.size1() * val.size2();
         auto subdims = std::vector<size_t>(dims.begin() + ndim, dims.end());
-        size_t subsize = inspector<value_type>::getSize(subdims);
+        size_t subsize = compute_total_size(subdims);
         for (size_t i = 0; i < size; ++i) {
             inspector<value_type>::serialize(*(&val(0, 0) + i), subdims, m + i * subsize);
         }
diff --git a/include/highfive/eigen.hpp b/include/highfive/eigen.hpp
index 275a68fad..69c01a7dc 100644
--- a/include/highfive/eigen.hpp
+++ b/include/highfive/eigen.hpp
@@ -39,10 +39,6 @@ struct inspector<Eigen::Matrix<T, M, N>> {
         return sizes;
     }
 
-    static size_t getSize(const std::vector<size_t>& dims) {
-        return compute_total_size(dims);
-    }
-
     static void prepare(type& val, const std::vector<size_t>& dims) {
         if (dims[0] != static_cast<size_t>(val.rows()) ||
             dims[1] != static_cast<size_t>(val.cols())) {