ENH: Add nx::core::Extent and unified readExtent API on AbstractDataStore

Adds nx::core::Extent (a strided N-dimensional range struct, moved from
simplnx-ooc) and pure-virtual readExtent/writeExtent on
AbstractDataStore<T>. This is the primary bulk-access API for
visualization code: the concrete store (DataStore for in-memory,
HDF5ChunkedStore for OOC) picks the optimal I/O primitive per call,
which lets the viz layer make one virtual call instead of hand-rolling
per-row copyIntoBuffer loops.

DataStore<T> implements the 3D fast path via std::memcpy on contiguous
X rows (the hot path for image geometries in ZYX tuple order). The
memcpy branch is guarded behind !std::is_same_v<T, bool> because
std::vector<bool> has no .data() accessor; bool falls through to a
per-tuple copy. 1D extents use a flat strided walk. EmptyDataStore
returns empty / no-ops as a placeholder.

Also updates MockOocDataStore in IParallelAlgorithmTest to override
the new virtuals (otherwise the mock is abstract and can't be
instantiated) and adds ExtentTest with 82 assertions covering
construction, contains/overlaps/intersect, equality, and strided
semantics.

Author: joeykleingers

CMakeLists.txt

@@ -353,6 +353,7 @@ set(SIMPLNX_HDRS
   ${SIMPLNX_SOURCE_DIR}/Common/Constants.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/DataTypeUtilities.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/DataVector.hpp
+  ${SIMPLNX_SOURCE_DIR}/Common/Extent.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/EulerAngle.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/Filesystem.hpp
   ${SIMPLNX_SOURCE_DIR}/Common/IteratorUtility.hpp

src/simplnx/Common/Extent.hpp

@@ -0,0 +1,179 @@
+#pragma once
+
+#include "simplnx/Common/Types.hpp"
+
+#include <algorithm>
+#include <limits>
+#include <numeric>
+#include <stdexcept>
+#include <vector>
+
+namespace nx::core
+{
+struct Extent
+{
+  std::vector<uint64> min;    // N-dimensional lower bounds (inclusive)
+  std::vector<uint64> max;    // N-dimensional upper bounds (inclusive)
+  std::vector<uint64> stride; // N-dimensional step sizes (default all-ones)
+
+  Extent() = default;
+
+  /**
+   * @brief Constructs an Extent from min and max bound vectors with default stride (all ones).
+   * Both vectors must have the same number of dimensions.
+   * @param minVal N-dimensional lower bounds (inclusive)
+   * @param maxVal N-dimensional upper bounds (inclusive)
+   * @throw std::invalid_argument if minVal and maxVal have different sizes
+   */
+  Extent(std::vector<uint64> minVal, std::vector<uint64> maxVal)
+  : min(std::move(minVal))
+  , max(std::move(maxVal))
+  , stride(min.size(), 1)
+  {
+    if(min.size() != max.size())
+    {
+      throw std::invalid_argument("Extent min and max must have the same number of dimensions");
+    }
+  }
+
+  /**
+   * @brief Constructs an Extent from min, max, and stride vectors.
+   * All vectors must have the same number of dimensions. Each stride value
+   * must be >= 1.
+   * @param minVal N-dimensional lower bounds (inclusive)
+   * @param maxVal N-dimensional upper bounds (inclusive)
+   * @param strideVal N-dimensional step sizes (>= 1 per dimension)
+   * @throw std::invalid_argument if sizes differ or any stride is zero
+   */
+  Extent(std::vector<uint64> minVal, std::vector<uint64> maxVal, std::vector<uint64> strideVal)
+  : min(std::move(minVal))
+  , max(std::move(maxVal))
+  , stride(std::move(strideVal))
+  {
+    if(min.size() != max.size() || min.size() != stride.size())
+    {
+      throw std::invalid_argument("Extent min, max, and stride must have the same number of dimensions");
+    }
+    for(uint64 d = 0; d < stride.size(); ++d)
+    {
+      if(stride[d] == 0)
+      {
+        throw std::invalid_argument("Extent stride must be >= 1 in every dimension");
+      }
+    }
+  }
+
+  /**
+   * @brief Returns the number of dimensions.
+   */
+  uint64 dimensions() const
+  {
+    return min.size();
+  }
+
+  /**
+   * @brief Returns the number of strided elements along the given dimension.
+   *
+   * With stride s, the selected indices are min[d], min[d]+s, min[d]+2s, ...
+   * up to max[d] (inclusive). The count is:
+   *   ceil((max[d] - min[d] + 1) / stride[d])
+   * which equals (max[d] - min[d] + stride[d]) / stride[d] using integer
+   * arithmetic (ceiling division).
+   */
+  uint64 size(uint64 dim) const
+  {
+    uint64 span = max[dim] - min[dim] + 1;
+    uint64 s = stride[dim];
+    return (span + s - 1) / s;
+  }
+
+  /**
+   * @brief Returns the product of all dimension sizes (accounting for stride).
+   */
+  uint64 totalElements() const
+  {
+    if(min.empty())
+    {
+      return 0;
+    }
+    uint64 total = 1;
+    for(uint64 d = 0; d < dimensions(); ++d)
+    {
+      uint64 s = size(d);
+      if(s > 0 && total > std::numeric_limits<uint64>::max() / s)
+      {
+        throw std::overflow_error("Extent::totalElements() overflow");
+      }
+      total *= s;
+    }
+    return total;
+  }
+
+  /**
+   * @brief Returns true if this extent fully contains the other extent.
+   * Containment is determined by min/max bounds only (stride-agnostic).
+   */
+  bool contains(const Extent& other) const
+  {
+    if(dimensions() != other.dimensions())
+    {
+      return false;
+    }
+    for(uint64 d = 0; d < dimensions(); ++d)
+    {
+      if(other.min[d] < min[d] || other.max[d] > max[d])
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @brief Returns true if this extent overlaps with the other extent.
+   * Adjacent extents (touching but not sharing elements) do NOT overlap.
+   * Overlap is determined by min/max bounds only (stride-agnostic).
+   */
+  bool overlaps(const Extent& other) const
+  {
+    if(dimensions() != other.dimensions())
+    {
+      return false;
+    }
+    for(uint64 d = 0; d < dimensions(); ++d)
+    {
+      if(max[d] < other.min[d] || other.max[d] < min[d])
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @brief Returns the intersection of this extent with the other extent.
+   * If the extents do not overlap, the result is an empty (0-dimensional) extent.
+   * The resulting stride in each dimension is the element-wise maximum of the
+   * two input strides.
+   */
+  Extent intersect(const Extent& other) const
+  {
+    if(!overlaps(other))
+    {
+      return Extent{};
+    }
+    std::vector<uint64> newMin(dimensions());
+    std::vector<uint64> newMax(dimensions());
+    std::vector<uint64> newStride(dimensions());
+    for(uint64 d = 0; d < dimensions(); ++d)
+    {
+      newMin[d] = std::max(min[d], other.min[d]);
+      newMax[d] = std::min(max[d], other.max[d]);
+      newStride[d] = std::max(stride[d], other.stride[d]);
+    }
+    return Extent{std::move(newMin), std::move(newMax), std::move(newStride)};
+  }
+
+  bool operator==(const Extent& other) const = default;
+};
+} // namespace nx::core

src/simplnx/DataStructure/AbstractDataStore.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "simplnx/Common/Result.hpp"
+#include "simplnx/Common/Extent.hpp"
 #include "simplnx/Common/StringLiteralFormatting.hpp"
 #include "simplnx/Common/TypesUtility.hpp"
 #include "simplnx/DataStructure/IDataStore.hpp"
@@ -468,6 +469,10 @@ class AbstractDataStore : public IDataStore
    */
   virtual Result<> copyFromBuffer(usize startIndex, nonstd::span<const T> buffer) = 0;
 
+  virtual std::vector<T> readExtent(const Extent& extent) const = 0;
+
+  virtual void writeExtent(const Extent& extent, nonstd::span<const T> data) = 0;
+
   /**
    * @brief Returns the value found at the specified index of the DataStore.
    * This cannot be used to edit the value found at the specified index.