Array2DRef: store Array1DRef internally, not a pointer

Author: LebedevRI

src/librawspeed/adt/Array2DRef.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include "adt/Array1DRef.h"
+#include "adt/CroppedArray1DRef.h" // IWYU pragma: keep
 #include "adt/Invariant.h"
 #include "adt/Optional.h"
 #include <cstddef>
@@ -31,7 +32,7 @@
 namespace rawspeed {
 
 template <class T> class Array2DRef final {
-  T* _data;
+  Array1DRef<T> data;
   int _pitch;
 
   friend Array2DRef<const T>; // We need to be able to convert to const version.
@@ -40,6 +41,8 @@ template <class T> class Array2DRef final {
   friend Array2DRef<std::byte>;
   friend Array2DRef<const std::byte>;
 
+  Array2DRef(Array1DRef<T> data, int width, int height, int pitch);
+
 public:
   void establishClassInvariants() const noexcept;
 
@@ -51,7 +54,9 @@ template <class T> class Array2DRef final {
 
   Array2DRef() = delete;
 
-  Array2DRef(T* data, int width, int height, int pitch = 0);
+  Array2DRef(T* data, int width, int height, int pitch);
+
+  Array2DRef(T* data, int width, int height);
 
   // Can not cast away constness.
   template <typename T2>
@@ -70,7 +75,7 @@ template <class T> class Array2DRef final {
     requires(!std::is_const_v<T2> && std::is_const_v<T> &&
              std::is_same_v<std::remove_const_t<T>, std::remove_const_t<T2>>)
   Array2DRef(Array2DRef<T2> RHS) // NOLINT google-explicit-constructor
-      : _data(RHS._data), _pitch(RHS._pitch), width(RHS.width),
+      : data(RHS.data), _pitch(RHS._pitch), width(RHS.width),
         height(RHS.height) {}
 
   // Const-preserving conversion from Array2DRef<T> to Array2DRef<std::byte>.
@@ -80,7 +85,7 @@ template <class T> class Array2DRef final {
                               std::remove_const_t<T2>>) &&
              std::is_same_v<std::remove_const_t<T>, std::byte>)
   Array2DRef(Array2DRef<T2> RHS) // NOLINT google-explicit-constructor
-      : _data(reinterpret_cast<T*>(RHS._data)), _pitch(sizeof(T2) * RHS._pitch),
+      : data(RHS.data), _pitch(sizeof(T2) * RHS._pitch),
         width(sizeof(T2) * RHS.width), height(RHS.height) {}
 
   template <typename AllocatorType =
@@ -102,26 +107,47 @@ template <class T> class Array2DRef final {
 
 // CTAD deduction guide
 template <typename T>
-explicit Array2DRef(T* data, int width, int height, int pitch = 0)
+explicit Array2DRef(Array1DRef<T> data, int width, int height, int pitch)
     -> Array2DRef<T>;
 
+// CTAD deduction guide
+template <typename T>
+explicit Array2DRef(T* data, int width, int height, int pitch) -> Array2DRef<T>;
+
+// CTAD deduction guide
+template <typename T>
+explicit Array2DRef(T* data, int width, int height) -> Array2DRef<T>;
+
 template <class T>
 inline void Array2DRef<T>::establishClassInvariants() const noexcept {
-  invariant(_data);
+  data.establishClassInvariants();
   invariant(width >= 0);
   invariant(height >= 0);
   invariant(_pitch >= 0);
   invariant(_pitch >= width);
   invariant((width == 0) == (height == 0));
   invariant((_pitch == 0) == (width == 0));
   invariant((_pitch == 0) == (height == 0));
+  invariant(data.size() == _pitch * height);
+}
+
+template <class T>
+Array2DRef<T>::Array2DRef(Array1DRef<T> data_, const int width_,
+                          const int height_, const int pitch_)
+    : data(data_), _pitch(pitch_), width(width_), height(height_) {
+  establishClassInvariants();
+}
+
+template <class T>
+Array2DRef<T>::Array2DRef(T* data_, const int width_, const int height_,
+                          const int pitch_)
+    : Array2DRef({data_, pitch_ * height_}, width_, height_, pitch_) {
+  establishClassInvariants();
 }
 
 template <class T>
-Array2DRef<T>::Array2DRef(T* data, const int width_, const int height_,
-                          const int pitch_ /* = 0 */)
-    : _data(data), _pitch(pitch_ == 0 ? width_ : pitch_), width(width_),
-      height(height_) {
+Array2DRef<T>::Array2DRef(T* data_, const int width_, const int height_)
+    : Array2DRef(data_, width_, height_, /*pitch=*/width_) {
   establishClassInvariants();
 }
 
@@ -130,7 +156,7 @@ template <class T>
 Array2DRef<T>::getAsArray1DRef() const {
   establishClassInvariants();
   if (height == 1 || _pitch == width)
-    return {{_data, width * height}};
+    return data.getCrop(/*offset=*/0, width * height).getAsArray1DRef();
   return std::nullopt;
 }
 
@@ -139,12 +165,7 @@ inline Array1DRef<T> Array2DRef<T>::operator[](const int row) const {
   establishClassInvariants();
   invariant(row >= 0);
   invariant(row < height);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wunknown-warning-option"
-#pragma GCC diagnostic ignored "-Wunsafe-buffer-usage"
-  return Array1DRef<T>(&_data[row * _pitch], width);
-#pragma GCC diagnostic pop
+  return data.getCrop(row * _pitch, width).getAsArray1DRef();
 }
 
 template <class T>