ENH: Add bulk getValues/setValues API to AbstractDataStore

Add virtual getValues() and setValues() methods to AbstractDataStore
for reading/writing contiguous ranges of elements in a single call.

DataStore overrides use std::memcpy for maximum throughput. ZarrStore
overrides (in FileStore plugin) use chunk-aware bulk access with three
optimizations: per-row memcpy, chunk-sticky shared_ptr reuse, and
multi-row extension when chunks cover full fast dimensions.

Existing methods fill(), copy(), copyFrom(), setTuple(), and
fillTuple() are rewritten to use the bulk API internally, so all
callers benefit automatically with no code changes.

Uses std::make_unique<T[]> for intermediate buffers to avoid the
std::vector<bool> bit-packing issue.

Author: joeykleingers

src/simplnx/DataStructure/AbstractDataStore.hpp

@@ -10,6 +10,7 @@
 #include <algorithm>
 #include <compare>
 #include <iterator>
+#include <memory>
 #include <vector>
 
 namespace nx::core
@@ -410,6 +411,44 @@ class AbstractDataStore : public IDataStore
    */
   virtual void setValue(usize index, value_type value) = 0;
 
+  /**
+   * @brief Reads a contiguous range of values from the DataStore into a buffer.
+   * Reads buffer.size() elements starting from startIndex.
+   * @param startIndex The first flat element index to read from
+   * @param buffer Span to write values into; buffer.size() determines count
+   */
+  virtual void getValues(usize startIndex, nonstd::span<T> buffer) const
+  {
+    const usize count = buffer.size();
+    if(startIndex + count > getSize())
+    {
+      throw std::out_of_range(fmt::format("AbstractDataStore::getValues: range [{}, {}) exceeds size {}", startIndex, startIndex + count, getSize()));
+    }
+    for(usize i = 0; i < count; i++)
+    {
+      buffer[i] = getValue(startIndex + i);
+    }
+  }
+
+  /**
+   * @brief Writes a contiguous range of values from a buffer into the DataStore.
+   * Writes buffer.size() elements starting at startIndex.
+   * @param startIndex The first flat element index to write to
+   * @param buffer Span of values to write; buffer.size() determines count
+   */
+  virtual void setValues(usize startIndex, nonstd::span<const T> buffer)
+  {
+    const usize count = buffer.size();
+    if(startIndex + count > getSize())
+    {
+      throw std::out_of_range(fmt::format("AbstractDataStore::setValues: range [{}, {}) exceeds size {}", startIndex, startIndex + count, getSize()));
+    }
+    for(usize i = 0; i < count; i++)
+    {
+      setValue(startIndex + i, buffer[i]);
+    }
+  }
+
   /**
    * @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.
@@ -584,7 +623,16 @@ class AbstractDataStore : public IDataStore
    */
   virtual void fill(value_type value)
   {
-    std::fill(begin(), end(), value);
+    const usize totalSize = getSize();
+    constexpr usize k_BulkBufferSize = 8192;
+    const usize bufSize = (std::min)(totalSize, k_BulkBufferSize);
+    auto buffer = std::make_unique<T[]>(bufSize);
+    std::fill_n(buffer.get(), bufSize, value);
+    for(usize offset = 0; offset < totalSize; offset += bufSize)
+    {
+      const usize batchSize = (std::min)(bufSize, totalSize - offset);
+      setValues(offset, nonstd::span<const T>(buffer.get(), batchSize));
+    }
   }
 
   /**
@@ -599,7 +647,17 @@ class AbstractDataStore : public IDataStore
     {
       return false;
     }
-    std::copy(other.begin(), other.end(), begin());
+    const usize totalSize = getSize();
+    constexpr usize k_BulkBufferSize = 8192;
+    const usize bufSize = (std::min)(totalSize, k_BulkBufferSize);
+    auto buffer = std::make_unique<T[]>(bufSize);
+    for(usize offset = 0; offset < totalSize; offset += bufSize)
+    {
+      const usize batchSize = (std::min)(bufSize, totalSize - offset);
+      nonstd::span<T> bufSpan(buffer.get(), batchSize);
+      other.getValues(offset, bufSpan);
+      setValues(offset, nonstd::span<const T>(buffer.get(), batchSize));
+    }
     return true;
   }
 
@@ -677,10 +735,25 @@ class AbstractDataStore : public IDataStore
                                          totalSrcTuples * sourceNumComponents, destTupleOffset * numComponents, getSize()));
     }
 
-    auto srcBegin = source.begin() + (srcTupleOffset * sourceNumComponents);
-    auto srcEnd = srcBegin + (totalSrcTuples * sourceNumComponents);
-    auto dstBegin = begin() + (destTupleOffset * numComponents);
-    std::copy(srcBegin, srcEnd, dstBegin);
+    const usize totalElements = totalSrcTuples * sourceNumComponents;
+    const usize srcStartIndex = srcTupleOffset * sourceNumComponents;
+    const usize dstStartIndex = destTupleOffset * numComponents;
+    constexpr usize k_BulkBufferSize = 8192;
+    const usize bufSize = (std::min)(totalElements, k_BulkBufferSize);
+    auto tempBuffer = std::make_unique<T[]>(bufSize);
+    usize remaining = totalElements;
+    usize srcOffset = srcStartIndex;
+    usize dstOffset = dstStartIndex;
+    while(remaining > 0)
+    {
+      const usize batchSize = (std::min)(remaining, bufSize);
+      nonstd::span<T> bufSpan(tempBuffer.get(), batchSize);
+      source.getValues(srcOffset, bufSpan);
+      setValues(dstOffset, nonstd::span<const T>(tempBuffer.get(), batchSize));
+      srcOffset += batchSize;
+      dstOffset += batchSize;
+      remaining -= batchSize;
+    }
     return {};
   }
 
@@ -693,10 +766,9 @@ class AbstractDataStore : public IDataStore
   {
     usize numComponents = getNumberOfComponents();
     index_type offset = tupleIndex * numComponents;
-    for(usize i = 0; i < numComponents; i++)
-    {
-      setValue(offset + i, value);
-    }
+    auto tupleValues = std::make_unique<T[]>(numComponents);
+    std::fill_n(tupleValues.get(), numComponents, value);
+    setValues(offset, nonstd::span<const T>(tupleValues.get(), numComponents));
   }
 
   /**
@@ -743,13 +815,8 @@ class AbstractDataStore : public IDataStore
       throw std::runtime_error(ss);
     }
 
-    index_type numComponents = getNumberOfComponents();
-    index_type offset = tupleIndex * numComponents;
-    usize count = values.size();
-    for(usize i = 0; i < count; i++)
-    {
-      setValue(offset + i, values[i]);
-    }
+    index_type offset = tupleIndex * getNumberOfComponents();
+    setValues(offset, values);
   }
 
   /**

src/simplnx/DataStructure/DataStore.hpp

@@ -505,6 +505,45 @@ class DataStore : public AbstractDataStore<T>
     std::swap(m_Data.get()[index1], m_Data.get()[index2]);
   }
 
+  /**
+   * @brief Reads a contiguous range of values using memcpy.
+   * @param startIndex The first flat element index to read from
+   * @param buffer Span to write values into
+   */
+  void getValues(usize startIndex, nonstd::span<T> buffer) const override
+  {
+    const usize count = buffer.size();
+    if(startIndex + count > this->getSize())
+    {
+      throw std::out_of_range(fmt::format("DataStore::getValues: range [{}, {}) exceeds size {}", startIndex, startIndex + count, this->getSize()));
+    }
+    std::memcpy(buffer.data(), m_Data.get() + startIndex, count * sizeof(T));
+  }
+
+  /**
+   * @brief Writes a contiguous range of values using memcpy.
+   * @param startIndex The first flat element index to write to
+   * @param buffer Span of values to write
+   */
+  void setValues(usize startIndex, nonstd::span<const T> buffer) override
+  {
+    const usize count = buffer.size();
+    if(startIndex + count > this->getSize())
+    {
+      throw std::out_of_range(fmt::format("DataStore::setValues: range [{}, {}) exceeds size {}", startIndex, startIndex + count, this->getSize()));
+    }
+    std::memcpy(m_Data.get() + startIndex, buffer.data(), count * sizeof(T));
+  }
+
+  /**
+   * @brief Fills the DataStore with the specified value using direct array access.
+   * @param value
+   */
+  void fill(value_type value) override
+  {
+    std::fill_n(m_Data.get(), this->getSize(), value);
+  }
+
   /**
    * @brief Returns a deep copy of the data store and all its data.
    * @return std::unique_ptr<IDataStore>