simplify slice some more

include/exiv2/slice.hpp

@@ -143,7 +143,7 @@ struct ConstSliceBase : SliceBase {
     if (new_end > this->end_) {
       throw std::out_of_range("Invalid input parameters to slice");
     }
-    return slice_type(storage_.data_, new_begin, new_end);
+    return {storage_.data_, new_begin, new_end};
   }
 
  protected:
@@ -227,7 +227,7 @@ struct MutableSliceBase : public ConstSliceBase<storage_type, data_type> {
    * mutable_slice_base.
    */
   template <typename slice_type>
-  slice_type subSlice(size_t begin, size_t end) {
+  [[nodiscard]] slice_type subSlice(size_t begin, size_t end) {
     this->rangeCheck(begin);
     // end == size() is a legal value, since end is the first
     // element beyond the slice
@@ -241,7 +241,7 @@ struct MutableSliceBase : public ConstSliceBase<storage_type, data_type> {
     if (new_end > this->end_) {
       throw std::out_of_range("Invalid input parameters to slice");
     }
-    return slice_type(this->storage_.data_, new_begin, new_end);
+    return {this->storage_.data_, new_begin, new_end};
   }
 };
 
@@ -429,19 +429,6 @@ struct Slice : public Internal::MutableSliceBase<Internal::ContainerStorage, con
   using value_type = typename std::remove_cv<typename container::value_type>::type;
 #endif
 
-  /*!
-   * Construct a sub-slice of this slice with the given bounds. The bounds
-   * are evaluated with respect to the current slice.
-   *
-   * @param[in] begin  First element in the new slice.
-   * @param[in] end  First element beyond the new slice.
-   *
-   * @throw std::out_of_range when begin or end are invalid
-   */
-  Slice subSlice(size_t begin, size_t end) {
-    return Internal::MutableSliceBase<Internal::ContainerStorage, container>::template subSlice<Slice>(begin, end);
-  }
-
   /*!
    * Constructs a new constant subSlice. Behaves otherwise exactly like
    * the non-const version.
@@ -466,7 +453,7 @@ struct Slice<const container> : public Internal::ConstSliceBase<Internal::Contai
   using value_type = typename std::remove_cv<typename container::value_type>::type;
 #endif
 
-  Slice subSlice(size_t begin, size_t end) const {
+  [[nodiscard]] Slice subSlice(size_t begin, size_t end) const {
     return Internal::ConstSliceBase<Internal::ContainerStorage,
                                     const container>::template subSlice<Slice<const container>>(begin, end);
   }
@@ -499,7 +486,7 @@ struct Slice<const T*> : public Internal::ConstSliceBase<Internal::PtrSliceStora
     // TODO: use using in C++11
   }
 
-  Slice<const T*> subSlice(size_t begin, size_t end) const {
+  [[nodiscard]] Slice<const T*> subSlice(size_t begin, size_t end) const {
     return Internal::ConstSliceBase<Internal::PtrSliceStorage, const T*>::template subSlice<Slice<const T*>>(begin,
                                                                                                              end);
   }
@@ -514,7 +501,7 @@ struct Slice<T*> : public Internal::MutableSliceBase<Internal::PtrSliceStorage,
     // TODO: use using in C++11
   }
 
-  Slice<T*> subSlice(size_t begin, size_t end) {
+  [[nodiscard]] Slice<T*> subSlice(size_t begin, size_t end) {
     return Internal::MutableSliceBase<Internal::PtrSliceStorage, T*>::template subSlice<Slice<T*>>(begin, end);
   }
 
@@ -531,23 +518,23 @@ struct Slice<T*> : public Internal::MutableSliceBase<Internal::PtrSliceStorage,
  */
 template <typename T>
 inline Slice<T> makeSlice(T& cont, size_t begin, size_t end) {
-  return Slice<T>(cont, begin, end);
+  return {cont, begin, end};
 }
 
 /*!
  * Overload of makeSlice for slices of C-arrays.
  */
 template <typename T>
 inline Slice<T*> makeSlice(T* ptr, size_t begin, size_t end) {
-  return Slice<T*>(ptr, begin, end);
+  return {ptr, begin, end};
 }
 
 /*!
  * @brief Return a new slice spanning the whole container.
  */
 template <typename container>
 inline Slice<container> makeSlice(container& cont) {
-  return Slice<container>(cont, 0, cont.size());
+  return {cont, 0, cont.size()};
 }
 
 /*!
@@ -556,23 +543,23 @@ inline Slice<container> makeSlice(container& cont) {
  */
 template <typename container>
 inline Slice<container> makeSliceFrom(container& cont, size_t begin) {
-  return Slice<container>(cont, begin, cont.size());
+  return {cont, begin, cont.size()};
 }
 
 /*!
  * @brief Return a new slice spanning until `end`.
  */
 template <typename container>
 inline Slice<container> makeSliceUntil(container& cont, size_t end) {
-  return Slice<container>(cont, 0, end);
+  return {cont, 0, end};
 }
 
 /*!
  * Overload of makeSliceUntil for pointer based slices.
  */
 template <typename T>
 inline Slice<T*> makeSliceUntil(T* ptr, size_t end) {
-  return Slice<T*>(ptr, 0, end);
+  return {ptr, 0, end};
 }
 
 }  // namespace Exiv2

unitTests/test_slice.cpp

@@ -152,20 +152,18 @@ TYPED_TEST_P(slice, constructionFailsWithZeroLength) {
  * Test the construction of subSlices and their behavior.
  */
 TYPED_TEST_P(slice, subSliceSuccessfulConstruction) {
-  using slice_t = Slice<TypeParam>;
-
   // 0 1 2 3 4 5 6 7 8 9
   //       |     |       center_vals
   //         | |         middle
-  slice_t center_vals = this->getTestSlice(3, 7);
+  auto center_vals = this->getTestSlice(3, 7);
   ASSERT_EQ(center_vals.size(), static_cast<size_t>(4));
-  ASSERT_NO_THROW(center_vals.subSlice(1, 3));
+  ASSERT_NO_THROW(auto t = center_vals.subSlice(1, 3));
 
-  ASSERT_NO_THROW(center_vals.subSlice(1, center_vals.size()));
+  ASSERT_NO_THROW(auto t = center_vals.subSlice(1, center_vals.size()));
 }
 
 TYPED_TEST_P(slice, subSliceFunctions) {
-  Slice<TypeParam> middle = this->getTestSlice(3, 7).subSlice(1, 3);
+  auto middle = this->getTestSlice(3, 7).subSlice(1, 3);
 
   ASSERT_EQ(middle.size(), static_cast<size_t>(2));
   ASSERT_EQ(middle.at(1), static_cast<typename Slice<TypeParam>::value_type>(5));
@@ -176,17 +174,17 @@ TYPED_TEST_P(slice, subSliceFailedConstruction) {
   //         | |         middle
   Slice<TypeParam> middle = this->getTestSlice(4, 6);
 
-  ASSERT_THROW(middle.subSlice(1, 5), std::out_of_range);
-  ASSERT_THROW(middle.subSlice(2, 1), std::out_of_range);
-  ASSERT_THROW(middle.subSlice(2, 2), std::out_of_range);
+  ASSERT_THROW(auto t = middle.subSlice(1, 5), std::out_of_range);
+  ASSERT_THROW(auto t = middle.subSlice(2, 1), std::out_of_range);
+  ASSERT_THROW(auto t = middle.subSlice(2, 2), std::out_of_range);
 }
 
 /*! try to cause integer overflows in a sub-optimal implementation */
 TYPED_TEST_P(slice, subSliceConstructionOverflowResistance) {
   Slice<TypeParam> center_vals = this->getTestSlice(3, 7);
 
-  ASSERT_THROW(center_vals.subSlice(std::numeric_limits<size_t>::max() - 2, 3), std::out_of_range);
-  ASSERT_THROW(center_vals.subSlice(2, std::numeric_limits<size_t>::max() - 1), std::out_of_range);
+  ASSERT_THROW(auto t = center_vals.subSlice(std::numeric_limits<size_t>::max() - 2, 3), std::out_of_range);
+  ASSERT_THROW(auto t = center_vals.subSlice(2, std::numeric_limits<size_t>::max() - 1), std::out_of_range);
 }
 
 /*!