Copy settings.

src/include/zarr.h

@@ -154,6 +154,10 @@ extern "C"
     /** @brief Destroy a Zarr stream settings struct. Consumes the pointer */
     void ZarrStreamSettings_destroy(ZarrStreamSettings* settings);
 
+    /** @brief Make a copy of the Zarr stream settings struct. */
+    ZarrStreamSettings* ZarrStreamSettings_copy(
+      const ZarrStreamSettings* settings);
+
     /***************************************************************************
      * Functions for setting parameters for a Zarr stream.
      *
@@ -523,6 +527,9 @@ extern "C"
 
     uint8_t ZarrStream_get_multiscale(const ZarrStream* stream);
 
+    /** @brief Get a copy of the stream settings. */
+    ZarrStreamSettings* ZarrStream_get_settings(const ZarrStream* stream);
+
     /***************************************************************************
      * Logging
      *

src/internal/stream.settings.cpp

@@ -113,6 +113,37 @@ ZarrStreamSettings_destroy(ZarrStreamSettings* settings)
     delete settings;
 }
 
+ZarrStreamSettings*
+ZarrStreamSettings_copy(const ZarrStreamSettings* settings)
+{
+    if (!settings) {
+        LOG_ERROR("Null pointer: settings");
+        return nullptr;
+    }
+
+    ZarrStreamSettings* copy = ZarrStreamSettings_create();
+    if (!copy) {
+        LOG_ERROR("Failed to allocate memory for copy");
+        return nullptr;
+    }
+
+    copy->store_path = settings->store_path;
+    copy->s3_endpoint = settings->s3_endpoint;
+    copy->s3_bucket_name = settings->s3_bucket_name;
+    copy->s3_access_key_id = settings->s3_access_key_id;
+    copy->s3_secret_access_key = settings->s3_secret_access_key;
+    copy->external_metadata = settings->external_metadata;
+    copy->dtype = settings->dtype;
+    copy->compressor = settings->compressor;
+    copy->compression_codec = settings->compression_codec;
+    copy->compression_level = settings->compression_level;
+    copy->compression_shuffle = settings->compression_shuffle;
+    copy->dimensions = settings->dimensions;
+    copy->multiscale = settings->multiscale;
+
+    return copy;
+}
+
 /* Setters */
 ZarrError
 ZarrStreamSettings_set_store_path(ZarrStreamSettings* settings,

src/internal/zarr.stream.cpp

@@ -315,6 +315,16 @@ extern "C"
         return ZarrStreamSettings_get_multiscale(&stream->settings());
     }
 
+    ZarrStreamSettings* ZarrStream_get_settings(const ZarrStream* stream)
+    {
+        if (!stream) {
+            LOG_WARNING("Null pointer: stream. Returning nullptr");
+            return nullptr;
+        }
+
+        return ZarrStreamSettings_copy(&stream->settings());
+    }
+
     /* Logging */
 
     ZarrError Zarr_set_log_level(LogLevel level)

tests/integration/CMakeLists.txt

@@ -3,6 +3,7 @@ set(project acquire-zarr)
 set(tests
         set-and-get-params
         create-and-destroy-stream
+        copy-settings
 )
 
 foreach (name ${tests})

tests/integration/copy-settings.cpp

@@ -0,0 +1,179 @@
+#include "zarr.h"
+#include "test.logger.hh"
+
+#include <cstring>
+#include <stdexcept>
+
+void
+test_ZarrStreamSettings_copy()
+{
+    // Create original settings
+    ZarrStreamSettings* original = ZarrStreamSettings_create();
+    CHECK(original != nullptr);
+
+    // Set various parameters
+    const char* store_path = "/path/to/store";
+    const char* s3_endpoint = "https://s3.amazonaws.com";
+    const char* s3_bucket_name = "my-bucket";
+    const char* s3_access_key_id = "access_key_123";
+    const char* s3_secret_access_key = "secret_key_456";
+    const char* external_metadata = "{\"key\":\"value\"}";
+
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_store_path(
+                original, store_path, strlen(store_path) + 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_s3_endpoint(
+                original, s3_endpoint, strlen(s3_endpoint) + 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_s3_bucket_name(
+                original, s3_bucket_name, strlen(s3_bucket_name) + 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_s3_access_key_id(
+                original, s3_access_key_id, strlen(s3_access_key_id) + 1));
+    EXPECT_EQ(
+      ZarrError,
+      "%d",
+      ZarrError_Success,
+      ZarrStreamSettings_set_s3_secret_access_key(
+        original, s3_secret_access_key, strlen(s3_secret_access_key) + 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_external_metadata(
+                original, external_metadata, strlen(external_metadata) + 1));
+
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_data_type(original, ZarrDataType_float32));
+    EXPECT_EQ(
+      ZarrError,
+      "%d",
+      ZarrError_Success,
+      ZarrStreamSettings_set_compressor(original, ZarrCompressor_Blosc1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_compression_codec(
+                original, ZarrCompressionCodec_BloscLZ4));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_compression_level(original, 5));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_compression_shuffle(original, 1));
+
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_reserve_dimensions(original, 3));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_dimension(
+                original, 0, "z", 2, ZarrDimensionType_Space, 100, 10, 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_dimension(
+                original, 1, "y", 2, ZarrDimensionType_Space, 200, 20, 1));
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_dimension(
+                original, 2, "x", 2, ZarrDimensionType_Space, 300, 30, 1));
+
+    EXPECT_EQ(ZarrError,
+              "%d",
+              ZarrError_Success,
+              ZarrStreamSettings_set_multiscale(original, 1));
+
+    // Copy the settings
+    ZarrStreamSettings* copy = ZarrStreamSettings_copy(original);
+    CHECK(copy != nullptr);
+
+    // Verify copied settings
+    EXPECT_STR_EQ(store_path, ZarrStreamSettings_get_store_path(copy));
+    EXPECT_STR_EQ(s3_endpoint, ZarrStreamSettings_get_s3_endpoint(copy));
+    EXPECT_STR_EQ(s3_bucket_name, ZarrStreamSettings_get_s3_bucket_name(copy));
+    EXPECT_STR_EQ(s3_access_key_id,
+                  ZarrStreamSettings_get_s3_access_key_id(copy));
+    EXPECT_STR_EQ(s3_secret_access_key,
+                  ZarrStreamSettings_get_s3_secret_access_key(copy));
+    EXPECT_STR_EQ(external_metadata,
+                  ZarrStreamSettings_get_external_metadata(copy));
+
+    EXPECT_EQ(ZarrDataType,
+              "%d",
+              ZarrDataType_float32,
+              ZarrStreamSettings_get_data_type(copy));
+    EXPECT_EQ(ZarrCompressor,
+              "%d",
+              ZarrCompressor_Blosc1,
+              ZarrStreamSettings_get_compressor(copy));
+    EXPECT_EQ(ZarrCompressionCodec,
+              "%d",
+              ZarrCompressionCodec_BloscLZ4,
+              ZarrStreamSettings_get_compression_codec(copy));
+    EXPECT_EQ(uint8_t, "%u", 5, ZarrStreamSettings_get_compression_level(copy));
+    EXPECT_EQ(
+      uint8_t, "%u", 1, ZarrStreamSettings_get_compression_shuffle(copy));
+
+    EXPECT_EQ(size_t, "%zu", 3, ZarrStreamSettings_get_dimension_count(copy));
+
+    // Check dimensions
+    for (size_t i = 0; i < 3; ++i) {
+        char name[3];
+        size_t bytes_of_name = sizeof(name);
+        ZarrDimensionType kind;
+        size_t array_size_px, chunk_size_px, shard_size_chunks;
+
+        EXPECT_EQ(ZarrError,
+                  "%d",
+                  ZarrError_Success,
+                  ZarrStreamSettings_get_dimension(copy,
+                                                   i,
+                                                   name,
+                                                   bytes_of_name,
+                                                   &kind,
+                                                   &array_size_px,
+                                                   &chunk_size_px,
+                                                   &shard_size_chunks));
+
+        const char* expected_name = (i == 0) ? "z" : (i == 1) ? "y" : "x";
+        EXPECT_STR_EQ(expected_name, name);
+        EXPECT_EQ(ZarrDimensionType, "%d", ZarrDimensionType_Space, kind);
+        EXPECT_EQ(size_t, "%zu", (i + 1) * 100, array_size_px);
+        EXPECT_EQ(size_t, "%zu", (i + 1) * 10, chunk_size_px);
+        EXPECT_EQ(size_t, "%zu", 1, shard_size_chunks);
+    }
+
+    EXPECT_EQ(uint8_t, "%u", 1, ZarrStreamSettings_get_multiscale(copy));
+
+    // Clean up
+    ZarrStreamSettings_destroy(original);
+    ZarrStreamSettings_destroy(copy);
+}
+
+int
+main()
+{
+    try {
+        test_ZarrStreamSettings_copy();
+    } catch (const std::exception& e) {
+        return 1;
+    }
+
+    return 0;
+}

tests/integration/test.logger.hh

@@ -53,3 +53,15 @@ class Logger
         T b_ = (T)(b);                                                         \
         EXPECT(a_ < b_, "Expected %s<%s but " fmt ">=" fmt, #a, #b, a_, b_);   \
     } while (0)
+
+#define EXPECT_STR_EQ(a, b)                                                    \
+    do {                                                                       \
+        std::string a_ = (a) ? (a) : "";                                       \
+        std::string b_ = (b) ? (b) : "";                                       \
+        EXPECT(a_ == b_,                                                       \
+               "Expected %s==%s but \"%s\"!=\"%s\"",                           \
+               #a,                                                             \
+               #b,                                                             \
+               a_.c_str(),                                                     \
+               b_.c_str());                                                    \
+    } while (0)