implement setAttributes and updateAttributes for v2

Author: brokkoli71

src/main/java/dev/zarr/zarrjava/core/Attributes.java

@@ -17,6 +17,16 @@ public Attributes(Map<String, Object> attributes) {
         super(attributes);
     }
 
+    public Attributes add(String s, Object o){
+        this.put(s, o);
+        return this;
+    }
+
+    public Attributes delete(String s){
+        this.remove(s);
+        return this;
+    }
+
     public boolean getBoolean(String key) {
         Object value = this.get(key);
         if (value instanceof Boolean) {

src/main/java/dev/zarr/zarrjava/v2/Array.java

@@ -177,6 +177,62 @@ public static ArrayMetadataBuilder metadataBuilder(ArrayMetadata existingMetadat
     return ArrayMetadataBuilder.fromArrayMetadata(existingMetadata);
   }
 
+  private Array writeMetadata(ArrayMetadata newArrayMetadata) throws ZarrException, IOException {
+    return Array.create(storeHandle, newArrayMetadata, true);
+  }
+
+  /**
+   * Sets a new shape for the Zarr array. It only changes the metadata, no array data is modified or
+   * deleted. This method returns a new instance of the Zarr array class and the old instance
+   * becomes invalid.
+   *
+   * @param newShape the new shape of the Zarr array
+   * @throws ZarrException if the new metadata is invalid
+   * @throws IOException throws IOException if the new metadata cannot be serialized
+   */
+  public Array resize(long[] newShape) throws ZarrException, IOException {
+    //TODO: test
+    if (newShape.length != metadata.ndim()) {
+      throw new IllegalArgumentException(
+          "'newShape' needs to have rank '" + metadata.ndim() + "'.");
+    }
+
+    ArrayMetadata newArrayMetadata = ArrayMetadataBuilder.fromArrayMetadata(metadata)
+        .withShape(newShape)
+        .build();
+    return writeMetadata(newArrayMetadata);
+  }
+
+  /**
+   * Sets the attributes of the Zarr array. It overwrites and removes any existing attributes. This
+   * method returns a new instance of the Zarr array class and the old instance becomes invalid.
+   *
+   * @param newAttributes the new attributes of the Zarr array
+   * @throws ZarrException throws ZarrException if the new metadata is invalid
+   * @throws IOException throws IOException if the new metadata cannot be serialized
+   */
+  public Array setAttributes(Attributes newAttributes) throws ZarrException, IOException {
+    ArrayMetadata newArrayMetadata =
+        ArrayMetadataBuilder.fromArrayMetadata(metadata)
+            .withAttributes(newAttributes)
+            .build();
+    return writeMetadata(newArrayMetadata);
+  }
+
+  /**
+   * Updates the attributes of the Zarr array. It provides a callback that gets the current
+   * attributes as input and needs to return the new set of attributes. The attributes in the
+   * callback may be mutated. This method overwrites and removes any existing attributes. This
+   * method returns a new instance of the Zarr array class and the old instance becomes invalid.
+   *
+   * @param attributeMapper the callback that is used to construct the new attributes
+   * @throws ZarrException throws ZarrException if the new metadata is invalid
+   * @throws IOException   throws IOException if the new metadata cannot be serialized
+   */
+  public Array updateAttributes(Function<Attributes, Attributes> attributeMapper) throws ZarrException, IOException {
+    return setAttributes(attributeMapper.apply(metadata.attributes));
+  }
+
   @Override
   public String toString() {
     return String.format("<v2.Array {%s} (%s) %s>", storeHandle,

src/main/java/dev/zarr/zarrjava/v3/Array.java

@@ -183,11 +183,7 @@ public static ArrayMetadataBuilder metadataBuilder(ArrayMetadata existingMetadat
   }
 
   private Array writeMetadata(ArrayMetadata newArrayMetadata) throws ZarrException, IOException {
-    ObjectMapper objectMapper = makeObjectMapper();
-    ByteBuffer metadataBytes = ByteBuffer.wrap(objectMapper.writeValueAsBytes(newArrayMetadata));
-    storeHandle.resolve(ZARR_JSON)
-        .set(metadataBytes);
-    return new Array(storeHandle, newArrayMetadata);
+    return Array.create(storeHandle, newArrayMetadata, true);
   }
 
   /**
@@ -238,8 +234,7 @@ public Array setAttributes(Attributes newAttributes) throws ZarrException, IOExc
    * @throws IOException   throws IOException if the new metadata cannot be serialized
    */
   public Array updateAttributes(Function<Attributes, Attributes> attributeMapper) throws ZarrException, IOException {
-    return setAttributes(attributeMapper.apply(new Attributes(metadata.attributes) {
-    }));
+    return setAttributes(attributeMapper.apply(metadata.attributes));
   }
 
   @Override

src/main/java/dev/zarr/zarrjava/v3/ArrayMetadata.java

@@ -150,7 +150,7 @@ public Attributes attributes() throws ZarrException {
     if (attributes == null) {
       throw new ZarrException("Array attributes have not been set.");
     }
-    return new Attributes(attributes); //todo change attributes to Attributes type
+    return attributes;
   }
 
   public static Optional<Codec> getShardingIndexedCodec(Codec[] codecs) {

src/test/java/dev/zarr/zarrjava/ZarrAttributesTest.java

@@ -1,13 +1,16 @@
 package dev.zarr.zarrjava;
 
+import dev.zarr.zarrjava.core.Attributes;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 
-import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.List;
 import java.util.stream.Stream;
 
 public class ZarrTest {
@@ -30,4 +33,81 @@ public static void clearTestoutputFolder() throws IOException {
         }
         Files.createDirectory(TESTOUTPUT);
     }
+
+    protected void assertListEquals(List<Object> a, List<Object> b) {
+        Assertions.assertEquals(a.size(), b.size());
+        for (int i = 0; i < a.size(); i++) {
+            Object aval = a.get(i);
+            Object bval = b.get(i);
+            if (aval instanceof List && bval instanceof List) {
+                assertListEquals((List<Object>) aval, (List<Object>) bval);
+            } else {
+                Assertions.assertEquals(aval, bval);
+            }
+        }
+    }
+
+    protected Attributes defaultTestAttributes() {
+        return new Attributes() {{
+            put("string", "stringvalue");
+            put("int", 42);
+            put("float", 0.5f);
+            put("double", 3.14);
+            put("boolean", true);
+            put("list", new ArrayList<Object>() {
+                {
+                    add(1);
+                    add(2.0d);
+                    add("string");
+                }
+            });
+            put("int_array", new int[]{1, 2, 3});
+            put("long_array", new long[]{1, 2, 3});
+            put("double_array", new double[]{1.0, 2.0, 3.0});
+            put("float_array", new float[]{1.0f, 2.0f, 3.0f});
+            put("nested", new Attributes() {{
+                put("element", "value");
+            }});
+            put("array_of_attributes", new Attributes[]{
+                new Attributes() {{
+                    put("a", 1);
+                }},
+                new Attributes() {{
+                    put("b", 2);
+                }}
+            });
+        }};
+    }
+
+    protected void assertContainsTestAttributes(Attributes attributes) throws ZarrException {
+        Assertions.assertEquals("stringvalue", attributes.getString("string"));
+        Assertions.assertEquals(42, attributes.getInt("int"));
+        Assertions.assertEquals(0.5, attributes.getFloat("float"));
+        Assertions.assertEquals(3.14, attributes.getDouble("double"));
+        Assertions.assertTrue(attributes.getBoolean("boolean"));
+        assertListEquals(new ArrayList<Object>() {
+            {
+                add(1);
+                add(2.0d);
+                add("string");
+            }
+        }, attributes.getList("list"));
+        Assertions.assertArrayEquals(new int[]{1, 2, 3}, attributes.getIntArray("int_array"));
+        Assertions.assertArrayEquals(new long[]{1, 2, 3}, attributes.getLongArray("long_array"));
+        Assertions.assertArrayEquals(new double[]{1, 2, 3}, attributes.getDoubleArray("double_array"));
+        Assertions.assertArrayEquals(new float[]{1, 2, 3}, attributes.getFloatArray("float_array"));
+        Assertions.assertEquals("value", attributes.getAttributes("nested").getString("element"));
+        Assertions.assertArrayEquals(
+            new Attributes[]{
+                new Attributes() {{
+                    put("a", 1);
+                }},
+                new Attributes() {{
+                    put("b", 2);
+                }}
+            },
+            attributes.getArray("array_of_attributes", Attributes.class)
+        );
+    }
+
 }